Fix wsl_v5 lint errors and exclude node_modules from linting

.golangci.yml

@@ -18,3 +18,6 @@ linters:
       default: default
       enable:
         - after-block
+  exclusions:
+    paths:
+      - node_modules

GNUmakefile

@@ -333,6 +333,15 @@ genmodels: ## Refresh LLM model registry from OpenRouter
 help: ## Show this help
 	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | sort | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}'
 
+.PHONY: fix
+fix: fix-go ## Auto-fix Go code
+
+.PHONY: fix-go
+fix-go: generate embed ## Auto-fix Go code (format, go fix, lint --fix)
+	gofmt -w apps cmd packages pkg e2e
+	$(GO_BASE) fix -omitzero=false ./apps/... ./cmd/... ./packages/... ./pkg/... ./e2e/...
+	$(GOLINTCMD) run --fix ./...
+
 .PHONY: fmt
 fmt: fmt-go ## Format Go code
 

e2e/console/risk_assessment_test.go

@@ -40,6 +40,7 @@ func TestRiskAssessment_Create(t *testing.T) {
 				} `json:"riskAssessmentEdge"`
 			} `json:"createRiskAssessment"`
 		}
+
 		err := owner.Execute(`
 			mutation($input: CreateRiskAssessmentInput!) {
 				createRiskAssessment(input: $input) {
@@ -81,6 +82,7 @@ func TestRiskAssessment_Delete(t *testing.T) {
 				ID string `json:"id"`
 			} `json:"node"`
 		}
+
 		err = owner.Execute(`query($id: ID!) { node(id: $id) { ... on RiskAssessmentScope { id } } }`,
 			map[string]any{"id": scopeID}, &result)
 		testutil.AssertNodeNotAccessible(t, err, result.Node == nil, "RiskAssessmentScope")
@@ -111,6 +113,7 @@ func TestRiskAssessmentScope_CRUD(t *testing.T) {
 				} `json:"scopes"`
 			} `json:"node"`
 		}
+
 		err := owner.Execute(`
 			query($id: ID!) {
 				node(id: $id) {
@@ -150,6 +153,7 @@ func TestRiskAssessmentNode_Create(t *testing.T) {
 					} `json:"riskAssessmentNodeEdge"`
 				} `json:"createRiskAssessmentNode"`
 			}
+
 			err := owner.Execute(`
 				mutation($input: CreateRiskAssessmentNodeInput!) {
 					createRiskAssessmentNode(input: $input) {
@@ -191,6 +195,7 @@ func TestRiskAssessmentProcess_Create(t *testing.T) {
 			} `json:"riskAssessmentProcessEdge"`
 		} `json:"createRiskAssessmentProcess"`
 	}
+
 	err := owner.Execute(`
 		mutation($input: CreateRiskAssessmentProcessInput!) {
 			createRiskAssessmentProcess(input: $input) {
@@ -232,6 +237,7 @@ func TestRiskAssessmentThreat_Create(t *testing.T) {
 			} `json:"riskAssessmentThreatEdge"`
 		} `json:"createRiskAssessmentThreat"`
 	}
+
 	err := owner.Execute(`
 		mutation($input: CreateRiskAssessmentThreatInput!) {
 			createRiskAssessmentThreat(input: $input) {
@@ -269,6 +275,7 @@ func TestRiskAssessmentScenario_Create(t *testing.T) {
 			} `json:"riskAssessmentScenarioEdge"`
 		} `json:"createRiskAssessmentScenario"`
 	}
+
 	err := owner.Execute(`
 		mutation($input: CreateRiskAssessmentScenarioInput!) {
 			createRiskAssessmentScenario(input: $input) {
@@ -314,6 +321,7 @@ func TestRiskAssessmentScenario_ListViaRisk(t *testing.T) {
 			} `json:"scenarios"`
 		} `json:"node"`
 	}
+
 	err := owner.Execute(`
 		query($id: ID!) {
 			node(id: $id) {
@@ -355,6 +363,7 @@ func TestRiskAssessmentScenario_ListViaScope(t *testing.T) {
 			} `json:"scenarios"`
 		} `json:"node"`
 	}
+
 	err := owner.Execute(`
 		query($id: ID!) {
 			node(id: $id) {
@@ -388,6 +397,7 @@ func TestRiskAssessment_Update(t *testing.T) {
 			} `json:"riskAssessment"`
 		} `json:"updateRiskAssessment"`
 	}
+
 	err := owner.Execute(`
 		mutation($input: UpdateRiskAssessmentInput!) {
 			updateRiskAssessment(input: $input) {
@@ -423,6 +433,7 @@ func TestRiskAssessmentScope_Update(t *testing.T) {
 			} `json:"riskAssessmentScope"`
 		} `json:"updateRiskAssessmentScope"`
 	}
+
 	err := owner.Execute(`
 		mutation($input: UpdateRiskAssessmentScopeInput!) {
 			updateRiskAssessmentScope(input: $input) {
@@ -457,6 +468,7 @@ func TestRiskAssessmentNode_Update(t *testing.T) {
 			} `json:"riskAssessmentNode"`
 		} `json:"updateRiskAssessmentNode"`
 	}
+
 	err := owner.Execute(`
 		mutation($input: UpdateRiskAssessmentNodeInput!) {
 			updateRiskAssessmentNode(input: $input) {
@@ -494,6 +506,7 @@ func TestRiskAssessmentProcess_Update(t *testing.T) {
 			} `json:"riskAssessmentProcess"`
 		} `json:"updateRiskAssessmentProcess"`
 	}
+
 	err := owner.Execute(`
 		mutation($input: UpdateRiskAssessmentProcessInput!) {
 			updateRiskAssessmentProcess(input: $input) {
@@ -531,6 +544,7 @@ func TestRiskAssessmentThreat_Update(t *testing.T) {
 			} `json:"riskAssessmentThreat"`
 		} `json:"updateRiskAssessmentThreat"`
 	}
+
 	err := owner.Execute(`
 		mutation($input: UpdateRiskAssessmentThreatInput!) {
 			updateRiskAssessmentThreat(input: $input) {
@@ -567,6 +581,7 @@ func TestRiskAssessmentScenario_Update(t *testing.T) {
 			} `json:"riskAssessmentScenario"`
 		} `json:"updateRiskAssessmentScenario"`
 	}
+
 	err := owner.Execute(`
 		mutation($input: UpdateRiskAssessmentScenarioInput!) {
 			updateRiskAssessmentScenario(input: $input) {
@@ -609,6 +624,7 @@ func TestRiskAssessmentScenario_LinkUnlinkThreat(t *testing.T) {
 			} `json:"threats"`
 		} `json:"node"`
 	}
+
 	err := owner.Execute(`
 		query($id: ID!) {
 			node(id: $id) {
@@ -665,6 +681,7 @@ func TestRiskAssessmentScenario_LinkUnlinkRisk(t *testing.T) {
 			} `json:"risks"`
 		} `json:"node"`
 	}
+
 	err := owner.Execute(`
 		query($id: ID!) {
 			node(id: $id) {
@@ -735,6 +752,7 @@ func TestRiskAssessment_RBAC(t *testing.T) {
 				Name string `json:"name"`
 			} `json:"node"`
 		}
+
 		err := viewer.Execute(`
 			query($id: ID!) { node(id: $id) { ... on RiskAssessment { id name } } }
 		`, map[string]any{"id": raID}, &result)
@@ -755,6 +773,7 @@ func TestRiskAssessment_TenantIsolation(t *testing.T) {
 			ID string `json:"id"`
 		} `json:"node"`
 	}
+
 	err := owner2.Execute(`
 		query($id: ID!) { node(id: $id) { ... on RiskAssessment { id } } }
 	`, map[string]any{"id": raID}, &result)

e2e/internal/factory/factory.go

@@ -1467,10 +1467,12 @@ func ReportDetectedResources(c *testutil.Client, bannerID string, count int) {
 
 func CreateRiskAssessment(c *testutil.Client, attrs ...Attrs) string {
 	c.T.Helper()
+
 	var a Attrs
 	if len(attrs) > 0 {
 		a = attrs[0]
 	}
+
 	const query = `
 		mutation($input: CreateRiskAssessmentInput!) {
 			createRiskAssessment(input: $input) {
@@ -1478,6 +1480,7 @@ func CreateRiskAssessment(c *testutil.Client, attrs ...Attrs) string {
 			}
 		}
 	`
+
 	input := map[string]any{
 		"organizationId": c.GetOrganizationID().String(),
 		"name":           a.getString("name", SafeName("Risk Assessment")),
@@ -1485,6 +1488,7 @@ func CreateRiskAssessment(c *testutil.Client, attrs ...Attrs) string {
 	if desc := a.getStringPtr("description"); desc != nil {
 		input["description"] = *desc
 	}
+
 	var result struct {
 		CreateRiskAssessment struct {
 			RiskAssessmentEdge struct {
@@ -1494,17 +1498,21 @@ func CreateRiskAssessment(c *testutil.Client, attrs ...Attrs) string {
 			} `json:"riskAssessmentEdge"`
 		} `json:"createRiskAssessment"`
 	}
+
 	err := c.Execute(query, map[string]any{"input": input}, &result)
 	require.NoError(c.T, err, "createRiskAssessment mutation failed")
+
 	return result.CreateRiskAssessment.RiskAssessmentEdge.Node.ID
 }
 
 func CreateRiskAssessmentScope(c *testutil.Client, riskAssessmentID string, attrs ...Attrs) string {
 	c.T.Helper()
+
 	var a Attrs
 	if len(attrs) > 0 {
 		a = attrs[0]
 	}
+
 	const query = `
 		mutation($input: CreateRiskAssessmentScopeInput!) {
 			createRiskAssessmentScope(input: $input) {
@@ -1512,10 +1520,12 @@ func CreateRiskAssessmentScope(c *testutil.Client, riskAssessmentID string, attr
 			}
 		}
 	`
+
 	input := map[string]any{
 		"riskAssessmentId": riskAssessmentID,
 		"name":             a.getString("name", SafeName("Scope")),
 	}
+
 	var result struct {
 		CreateRiskAssessmentScope struct {
 			RiskAssessmentScopeEdge struct {
@@ -1525,17 +1535,21 @@ func CreateRiskAssessmentScope(c *testutil.Client, riskAssessmentID string, attr
 			} `json:"riskAssessmentScopeEdge"`
 		} `json:"createRiskAssessmentScope"`
 	}
+
 	err := c.Execute(query, map[string]any{"input": input}, &result)
 	require.NoError(c.T, err, "createRiskAssessmentScope mutation failed")
+
 	return result.CreateRiskAssessmentScope.RiskAssessmentScopeEdge.Node.ID
 }
 
 func CreateRiskAssessmentNode(c *testutil.Client, scopeID string, attrs ...Attrs) string {
 	c.T.Helper()
+
 	var a Attrs
 	if len(attrs) > 0 {
 		a = attrs[0]
 	}
+
 	const query = `
 		mutation($input: CreateRiskAssessmentNodeInput!) {
 			createRiskAssessmentNode(input: $input) {
@@ -1543,11 +1557,13 @@ func CreateRiskAssessmentNode(c *testutil.Client, scopeID string, attrs ...Attrs
 			}
 		}
 	`
+
 	input := map[string]any{
 		"riskAssessmentScopeId": scopeID,
 		"nodeType":              a.getString("nodeType", "ASSET"),
 		"name":                  a.getString("name", SafeName("Node")),
 	}
+
 	var result struct {
 		CreateRiskAssessmentNode struct {
 			RiskAssessmentNodeEdge struct {
@@ -1557,17 +1573,21 @@ func CreateRiskAssessmentNode(c *testutil.Client, scopeID string, attrs ...Attrs
 			} `json:"riskAssessmentNodeEdge"`
 		} `json:"createRiskAssessmentNode"`
 	}
+
 	err := c.Execute(query, map[string]any{"input": input}, &result)
 	require.NoError(c.T, err, "createRiskAssessmentNode mutation failed")
+
 	return result.CreateRiskAssessmentNode.RiskAssessmentNodeEdge.Node.ID
 }
 
 func CreateRiskAssessmentProcess(c *testutil.Client, scopeID, sourceNodeID, targetNodeID string, attrs ...Attrs) string {
 	c.T.Helper()
+
 	var a Attrs
 	if len(attrs) > 0 {
 		a = attrs[0]
 	}
+
 	const query = `
 		mutation($input: CreateRiskAssessmentProcessInput!) {
 			createRiskAssessmentProcess(input: $input) {
@@ -1575,12 +1595,14 @@ func CreateRiskAssessmentProcess(c *testutil.Client, scopeID, sourceNodeID, targ
 			}
 		}
 	`
+
 	input := map[string]any{
 		"riskAssessmentScopeId": scopeID,
 		"sourceNodeId":          sourceNodeID,
 		"targetNodeId":          targetNodeID,
 		"name":                  a.getString("name", SafeName("Process")),
 	}
+
 	var result struct {
 		CreateRiskAssessmentProcess struct {
 			RiskAssessmentProcessEdge struct {
@@ -1590,17 +1612,21 @@ func CreateRiskAssessmentProcess(c *testutil.Client, scopeID, sourceNodeID, targ
 			} `json:"riskAssessmentProcessEdge"`
 		} `json:"createRiskAssessmentProcess"`
 	}
+
 	err := c.Execute(query, map[string]any{"input": input}, &result)
 	require.NoError(c.T, err, "createRiskAssessmentProcess mutation failed")
+
 	return result.CreateRiskAssessmentProcess.RiskAssessmentProcessEdge.Node.ID
 }
 
 func CreateRiskAssessmentThreat(c *testutil.Client, scopeID, processID string, attrs ...Attrs) string {
 	c.T.Helper()
+
 	var a Attrs
 	if len(attrs) > 0 {
 		a = attrs[0]
 	}
+
 	const query = `
 		mutation($input: CreateRiskAssessmentThreatInput!) {
 			createRiskAssessmentThreat(input: $input) {
@@ -1608,12 +1634,14 @@ func CreateRiskAssessmentThreat(c *testutil.Client, scopeID, processID string, a
 			}
 		}
 	`
+
 	input := map[string]any{
 		"riskAssessmentScopeId": scopeID,
 		"processId":             processID,
 		"name":                  a.getString("name", SafeName("Threat")),
 		"category":              a.getString("category", "Confidentiality"),
 	}
+
 	var result struct {
 		CreateRiskAssessmentThreat struct {
 			RiskAssessmentThreatEdge struct {
@@ -1623,17 +1651,21 @@ func CreateRiskAssessmentThreat(c *testutil.Client, scopeID, processID string, a
 			} `json:"riskAssessmentThreatEdge"`
 		} `json:"createRiskAssessmentThreat"`
 	}
+
 	err := c.Execute(query, map[string]any{"input": input}, &result)
 	require.NoError(c.T, err, "createRiskAssessmentThreat mutation failed")
+
 	return result.CreateRiskAssessmentThreat.RiskAssessmentThreatEdge.Node.ID
 }
 
 func CreateRiskAssessmentScenario(c *testutil.Client, scopeID string, attrs ...Attrs) string {
 	c.T.Helper()
+
 	var a Attrs
 	if len(attrs) > 0 {
 		a = attrs[0]
 	}
+
 	const query = `
 		mutation($input: CreateRiskAssessmentScenarioInput!) {
 			createRiskAssessmentScenario(input: $input) {
@@ -1641,6 +1673,7 @@ func CreateRiskAssessmentScenario(c *testutil.Client, scopeID string, attrs ...A
 			}
 		}
 	`
+
 	input := map[string]any{
 		"riskAssessmentScopeId": scopeID,
 		"name":                  a.getString("name", SafeName("Scenario")),
@@ -1648,6 +1681,7 @@ func CreateRiskAssessmentScenario(c *testutil.Client, scopeID string, attrs ...A
 	if desc := a.getStringPtr("description"); desc != nil {
 		input["description"] = *desc
 	}
+
 	var result struct {
 		CreateRiskAssessmentScenario struct {
 			RiskAssessmentScenarioEdge struct {
@@ -1657,13 +1691,16 @@ func CreateRiskAssessmentScenario(c *testutil.Client, scopeID string, attrs ...A
 			} `json:"riskAssessmentScenarioEdge"`
 		} `json:"createRiskAssessmentScenario"`
 	}
+
 	err := c.Execute(query, map[string]any{"input": input}, &result)
 	require.NoError(c.T, err, "createRiskAssessmentScenario mutation failed")
+
 	return result.CreateRiskAssessmentScenario.RiskAssessmentScenarioEdge.Node.ID
 }
 
 func LinkRiskAssessmentScenarioThreat(c *testutil.Client, scenarioID, threatID string) {
 	c.T.Helper()
+
 	const query = `
 		mutation($input: LinkRiskAssessmentScenarioThreatInput!) {
 			linkRiskAssessmentScenarioThreat(input: $input) {
@@ -1671,6 +1708,7 @@ func LinkRiskAssessmentScenarioThreat(c *testutil.Client, scenarioID, threatID s
 			}
 		}
 	`
+
 	_, err := c.Do(query, map[string]any{
 		"input": map[string]any{
 			"riskAssessmentScenarioId": scenarioID,
@@ -1682,6 +1720,7 @@ func LinkRiskAssessmentScenarioThreat(c *testutil.Client, scenarioID, threatID s
 
 func LinkRiskAssessmentScenarioRisk(c *testutil.Client, scenarioID, riskID string) {
 	c.T.Helper()
+
 	const query = `
 		mutation($input: LinkRiskAssessmentScenarioRiskInput!) {
 			linkRiskAssessmentScenarioRisk(input: $input) {
@@ -1689,6 +1728,7 @@ func LinkRiskAssessmentScenarioRisk(c *testutil.Client, scenarioID, riskID strin
 			}
 		}
 	`
+
 	_, err := c.Do(query, map[string]any{
 		"input": map[string]any{
 			"riskAssessmentScenarioId": scenarioID,

pkg/accessreview/drivers/heroku.go

@@ -76,6 +76,7 @@ func (d *HerokuDriver) ListAccounts(ctx context.Context) ([]AccountRecord, error
 	if err != nil {
 		return nil, fmt.Errorf("cannot build heroku members URL: %w", err)
 	}
+
 	rangeHeader := ""
 
 	for range maxPaginationPages {

pkg/coredata/risk_assessment.go

@@ -59,6 +59,7 @@ func (ra *RiskAssessment) AuthorizationAttributes(ctx context.Context, conn pg.Q
 		if errors.Is(err, pgx.ErrNoRows) {
 			return nil, ErrResourceNotFound
 		}
+
 		return nil, fmt.Errorf("cannot query risk assessment authorization attributes: %w", err)
 	}
 
@@ -192,6 +193,7 @@ VALUES (@id, @tenant_id, @organization_id, @name, @description, @created_at, @up
 	if err != nil {
 		return fmt.Errorf("cannot insert risk assessment: %w", err)
 	}
+
 	return nil
 }
 
@@ -246,5 +248,6 @@ DELETE FROM risk_assessments WHERE %s AND id = @id
 	maps.Copy(args, scope.SQLArguments())
 
 	_, err := conn.Exec(ctx, q, args)
+
 	return err
 }

pkg/coredata/risk_assessment_node.go

@@ -49,6 +49,7 @@ func (n *RiskAssessmentNode) CursorKey(orderBy RiskAssessmentNodeOrderField) pag
 	case RiskAssessmentNodeOrderFieldName:
 		return page.CursorKey{ID: n.ID, Value: n.Name}
 	}
+
 	panic(fmt.Sprintf("unsupported order by: %s", orderBy))
 }
 
@@ -60,6 +61,7 @@ func (n *RiskAssessmentNode) AuthorizationAttributes(ctx context.Context, conn p
 		if errors.Is(err, pgx.ErrNoRows) {
 			return nil, ErrResourceNotFound
 		}
+
 		return nil, fmt.Errorf("cannot query risk assessment node authorization attributes: %w", err)
 	}
 
@@ -98,11 +100,14 @@ WHERE
 	if err != nil {
 		return fmt.Errorf("cannot query risk assessment nodes: %w", err)
 	}
+
 	results, err := pgx.CollectRows(rows, pgx.RowToAddrOfStructByName[RiskAssessmentNode])
 	if err != nil {
 		return fmt.Errorf("cannot collect risk assessment nodes: %w", err)
 	}
+
 	*ns = results
+
 	return nil
 }
 
@@ -137,11 +142,14 @@ ORDER BY
 	if err != nil {
 		return fmt.Errorf("cannot query risk assessment nodes: %w", err)
 	}
+
 	results, err := pgx.CollectRows(rows, pgx.RowToAddrOfStructByName[RiskAssessmentNode])
 	if err != nil {
 		return fmt.Errorf("cannot collect risk assessment nodes: %w", err)
 	}
+
 	*ns = results
+
 	return nil
 }
 
@@ -169,6 +177,7 @@ WHERE
 	if err := conn.QueryRow(ctx, q, args).Scan(&count); err != nil {
 		return 0, fmt.Errorf("cannot count risk assessment nodes: %w", err)
 	}
+
 	return count, nil
 }
 
@@ -197,14 +206,18 @@ LIMIT 1;
 	if err != nil {
 		return fmt.Errorf("cannot query risk assessment node: %w", err)
 	}
+
 	result, err := pgx.CollectExactlyOneRow(rows, pgx.RowToStructByName[RiskAssessmentNode])
 	if err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return ErrResourceNotFound
 		}
+
 		return fmt.Errorf("cannot collect risk assessment node: %w", err)
 	}
+
 	*n = result
+
 	return nil
 }
 
@@ -240,13 +253,16 @@ INSERT INTO risk_assessment_nodes (
 		"created_at":               n.CreatedAt,
 		"updated_at":               n.UpdatedAt,
 	}
+
 	_, err := conn.Exec(ctx, q, args)
 	if err != nil {
 		if pgErr, ok := errors.AsType[*pgconn.PgError](err); ok && pgErr.Code == "23505" && pgErr.ConstraintName == "risk_assessment_nodes_unique_name" {
 			return ErrResourceAlreadyExists
 		}
+
 		return fmt.Errorf("cannot insert risk assessment node: %w", err)
 	}
+
 	return nil
 }
 
@@ -274,9 +290,11 @@ WHERE
 	if err != nil {
 		return fmt.Errorf("cannot update risk assessment node: %w", err)
 	}
+
 	if result.RowsAffected() == 0 {
 		return ErrResourceNotFound
 	}
+
 	return nil
 }
 
@@ -292,5 +310,6 @@ WHERE
 	maps.Copy(args, scope.SQLArguments())
 
 	_, err := conn.Exec(ctx, q, args)
+
 	return err
 }

pkg/coredata/risk_assessment_process.go

@@ -50,6 +50,7 @@ func (p *RiskAssessmentProcess) CursorKey(orderBy RiskAssessmentProcessOrderFiel
 	case RiskAssessmentProcessOrderFieldName:
 		return page.CursorKey{ID: p.ID, Value: p.Name}
 	}
+
 	panic(fmt.Sprintf("unsupported order by: %s", orderBy))
 }
 
@@ -61,6 +62,7 @@ func (p *RiskAssessmentProcess) AuthorizationAttributes(ctx context.Context, con
 		if errors.Is(err, pgx.ErrNoRows) {
 			return nil, ErrResourceNotFound
 		}
+
 		return nil, fmt.Errorf("cannot query risk assessment process authorization attributes: %w", err)
 	}
 
@@ -100,11 +102,14 @@ WHERE
 	if err != nil {
 		return fmt.Errorf("cannot query risk assessment processes: %w", err)
 	}
+
 	results, err := pgx.CollectRows(rows, pgx.RowToAddrOfStructByName[RiskAssessmentProcess])
 	if err != nil {
 		return fmt.Errorf("cannot collect risk assessment processes: %w", err)
 	}
+
 	*ps = results
+
 	return nil
 }
 
@@ -140,11 +145,14 @@ ORDER BY
 	if err != nil {
 		return fmt.Errorf("cannot query risk assessment processes: %w", err)
 	}
+
 	results, err := pgx.CollectRows(rows, pgx.RowToAddrOfStructByName[RiskAssessmentProcess])
 	if err != nil {
 		return fmt.Errorf("cannot collect risk assessment processes: %w", err)
 	}
+
 	*ps = results
+
 	return nil
 }
 
@@ -172,6 +180,7 @@ WHERE
 	if err := conn.QueryRow(ctx, q, args).Scan(&count); err != nil {
 		return 0, fmt.Errorf("cannot count risk assessment processes: %w", err)
 	}
+
 	return count, nil
 }
 
@@ -196,18 +205,23 @@ LIMIT 1;
 	q = fmt.Sprintf(q, scope.SQLFragment())
 	args := pgx.StrictNamedArgs{"id": id}
 	maps.Copy(args, scope.SQLArguments())
+
 	rows, err := conn.Query(ctx, q, args)
 	if err != nil {
 		return fmt.Errorf("cannot query risk assessment process: %w", err)
 	}
+
 	result, err := pgx.CollectExactlyOneRow(rows, pgx.RowToStructByName[RiskAssessmentProcess])
 	if err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return ErrResourceNotFound
 		}
+
 		return fmt.Errorf("cannot collect risk assessment process: %w", err)
 	}
+
 	*p = result
+
 	return nil
 }
 
@@ -246,13 +260,16 @@ INSERT INTO risk_assessment_processes (
 		"created_at":               p.CreatedAt,
 		"updated_at":               p.UpdatedAt,
 	}
+
 	_, err := conn.Exec(ctx, q, args)
 	if err != nil {
 		if pgErr, ok := errors.AsType[*pgconn.PgError](err); ok && pgErr.Code == "23505" && pgErr.ConstraintName == "risk_assessment_processes_unique_name" {
 			return ErrResourceAlreadyExists
 		}
+
 		return fmt.Errorf("cannot insert risk assessment process: %w", err)
 	}
+
 	return nil
 }
 
@@ -277,13 +294,16 @@ WHERE
 		"updated_at":     p.UpdatedAt,
 	}
 	maps.Copy(args, scope.SQLArguments())
+
 	result, err := conn.Exec(ctx, q, args)
 	if err != nil {
 		return fmt.Errorf("cannot update risk assessment process: %w", err)
 	}
+
 	if result.RowsAffected() == 0 {
 		return ErrResourceNotFound
 	}
+
 	return nil
 }
 
@@ -298,5 +318,6 @@ WHERE
 	args := pgx.StrictNamedArgs{"id": id}
 	maps.Copy(args, scope.SQLArguments())
 	_, err := conn.Exec(ctx, q, args)
+
 	return err
 }

pkg/coredata/risk_assessment_scenario.go

@@ -48,6 +48,7 @@ func (s *RiskAssessmentScenario) CursorKey(orderBy RiskAssessmentScenarioOrderFi
 	case RiskAssessmentScenarioOrderFieldName:
 		return page.CursorKey{ID: s.ID, Value: s.Name}
 	}
+
 	panic(fmt.Sprintf("unsupported order by: %s", orderBy))
 }
 
@@ -59,6 +60,7 @@ func (s *RiskAssessmentScenario) AuthorizationAttributes(ctx context.Context, co
 		if errors.Is(err, pgx.ErrNoRows) {
 			return nil, ErrResourceNotFound
 		}
+
 		return nil, fmt.Errorf("cannot query risk scenario authorization attributes: %w", err)
 	}
 
@@ -97,11 +99,14 @@ WHERE
 	if err != nil {
 		return fmt.Errorf("cannot query risk scenarios: %w", err)
 	}
+
 	results, err := pgx.CollectRows(rows, pgx.RowToAddrOfStructByName[RiskAssessmentScenario])
 	if err != nil {
 		return fmt.Errorf("cannot collect risk scenarios: %w", err)
 	}
+
 	*ss = results
+
 	return nil
 }
 
@@ -128,6 +133,7 @@ WHERE
 	if err := conn.QueryRow(ctx, q, args).Scan(&count); err != nil {
 		return 0, fmt.Errorf("cannot count risk scenarios: %w", err)
 	}
+
 	return count, nil
 }
 
@@ -172,11 +178,14 @@ WHERE
 	if err != nil {
 		return fmt.Errorf("cannot query risk scenarios: %w", err)
 	}
+
 	results, err := pgx.CollectRows(rows, pgx.RowToAddrOfStructByName[RiskAssessmentScenario])
 	if err != nil {
 		return fmt.Errorf("cannot collect risk scenarios: %w", err)
 	}
+
 	*ss = results
+
 	return nil
 }
 
@@ -212,6 +221,7 @@ WHERE
 	if err := conn.QueryRow(ctx, q, args).Scan(&count); err != nil {
 		return 0, fmt.Errorf("cannot count risk scenarios: %w", err)
 	}
+
 	return count, nil
 }
 
@@ -247,11 +257,14 @@ WHERE
 	if err != nil {
 		return fmt.Errorf("cannot query risk scenarios: %w", err)
 	}
+
 	results, err := pgx.CollectRows(rows, pgx.RowToAddrOfStructByName[RiskAssessmentScenario])
 	if err != nil {
 		return fmt.Errorf("cannot collect risk scenarios: %w", err)
 	}
+
 	*ss = results
+
 	return nil
 }
 
@@ -278,6 +291,7 @@ WHERE
 	if err := conn.QueryRow(ctx, q, args).Scan(&count); err != nil {
 		return 0, fmt.Errorf("cannot count risk scenarios: %w", err)
 	}
+
 	return count, nil
 }
 
@@ -301,18 +315,23 @@ LIMIT 1
 	q = fmt.Sprintf(q, scope.SQLFragment())
 	args := pgx.StrictNamedArgs{"id": id}
 	maps.Copy(args, scope.SQLArguments())
+
 	rows, err := conn.Query(ctx, q, args)
 	if err != nil {
 		return fmt.Errorf("cannot query risk scenario: %w", err)
 	}
+
 	result, err := pgx.CollectExactlyOneRow(rows, pgx.RowToStructByName[RiskAssessmentScenario])
 	if err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return ErrResourceNotFound
 		}
+
 		return fmt.Errorf("cannot collect risk scenario: %w", err)
 	}
+
 	*s = result
+
 	return nil
 }
 
@@ -348,10 +367,12 @@ INSERT INTO risk_assessment_scenarios (
 		"created_at":               s.CreatedAt,
 		"updated_at":               s.UpdatedAt,
 	}
+
 	_, err := conn.Exec(ctx, q, args)
 	if err != nil {
 		return fmt.Errorf("cannot insert risk scenario: %w", err)
 	}
+
 	return nil
 }
 
@@ -369,13 +390,16 @@ WHERE
 	q = fmt.Sprintf(q, scope.SQLFragment())
 	args := pgx.StrictNamedArgs{"id": s.ID, "name": s.Name, "description": s.Description, "updated_at": s.UpdatedAt}
 	maps.Copy(args, scope.SQLArguments())
+
 	result, err := conn.Exec(ctx, q, args)
 	if err != nil {
 		return fmt.Errorf("cannot update risk scenario: %w", err)
 	}
+
 	if result.RowsAffected() == 0 {
 		return ErrResourceNotFound
 	}
+
 	return nil
 }
 
@@ -390,5 +414,6 @@ WHERE
 	args := pgx.StrictNamedArgs{"id": id}
 	maps.Copy(args, scope.SQLArguments())
 	_, err := conn.Exec(ctx, q, args)
+
 	return err
 }

pkg/coredata/risk_assessment_scenario_risk.go

@@ -58,13 +58,16 @@ INSERT INTO risk_assessment_scenario_risks (
 		"risk_id":                     sr.RiskID,
 		"created_at":                  sr.CreatedAt,
 	}
+
 	_, err := conn.Exec(ctx, q, args)
 	if err != nil {
 		if pgErr, ok := errors.AsType[*pgconn.PgError](err); ok && pgErr.Code == "23505" && pgErr.ConstraintName == "risk_assessment_scenario_risks_pkey" {
 			return ErrResourceAlreadyExists
 		}
+
 		return fmt.Errorf("cannot insert risk scenario risk: %w", err)
 	}
+
 	return nil
 }
 
@@ -83,6 +86,7 @@ WHERE
 	}
 	maps.Copy(args, scope.SQLArguments())
 	_, err := conn.Exec(ctx, q, args)
+
 	return err
 }
 
@@ -137,11 +141,14 @@ WHERE
 	if err != nil {
 		return fmt.Errorf("cannot query risk scenario risks: %w", err)
 	}
+
 	results, err := pgx.CollectRows(rows, pgx.RowToAddrOfStructByName[Risk])
 	if err != nil {
 		return fmt.Errorf("cannot collect risk scenario risks: %w", err)
 	}
+
 	*rs = results
+
 	return nil
 }
 
@@ -177,5 +184,6 @@ WHERE
 	if err := conn.QueryRow(ctx, q, args).Scan(&count); err != nil {
 		return 0, fmt.Errorf("cannot count risk scenario risks: %w", err)
 	}
+
 	return count, nil
 }

pkg/coredata/risk_assessment_scenario_threat.go

@@ -58,13 +58,16 @@ INSERT INTO risk_assessment_scenario_threats (
 		"risk_assessment_threat_id":   st.RiskAssessmentThreatID,
 		"created_at":                  st.CreatedAt,
 	}
+
 	_, err := conn.Exec(ctx, q, args)
 	if err != nil {
 		if pgErr, ok := errors.AsType[*pgconn.PgError](err); ok && pgErr.Code == "23505" && pgErr.ConstraintName == "risk_assessment_scenario_threats_pkey" {
 			return ErrResourceAlreadyExists
 		}
+
 		return fmt.Errorf("cannot insert risk scenario threat: %w", err)
 	}
+
 	return nil
 }
 
@@ -83,6 +86,7 @@ WHERE
 	}
 	maps.Copy(args, scope.SQLArguments())
 	_, err := conn.Exec(ctx, q, args)
+
 	return err
 }
 
@@ -128,11 +132,14 @@ WHERE
 	if err != nil {
 		return fmt.Errorf("cannot query risk scenario threats: %w", err)
 	}
+
 	results, err := pgx.CollectRows(rows, pgx.RowToAddrOfStructByName[RiskAssessmentThreat])
 	if err != nil {
 		return fmt.Errorf("cannot collect risk scenario threats: %w", err)
 	}
+
 	*ts = results
+
 	return nil
 }
 
@@ -168,5 +175,6 @@ WHERE
 	if err := conn.QueryRow(ctx, q, args).Scan(&count); err != nil {
 		return 0, fmt.Errorf("cannot count risk scenario threats: %w", err)
 	}
+
 	return count, nil
 }

pkg/coredata/risk_assessment_scope.go

@@ -47,6 +47,7 @@ func (s *RiskAssessmentScope) CursorKey(orderBy RiskAssessmentScopeOrderField) p
 	case RiskAssessmentScopeOrderFieldName:
 		return page.CursorKey{ID: s.ID, Value: s.Name}
 	}
+
 	panic(fmt.Sprintf("unsupported order by: %s", orderBy))
 }
 
@@ -58,6 +59,7 @@ func (s *RiskAssessmentScope) AuthorizationAttributes(ctx context.Context, conn
 		if errors.Is(err, pgx.ErrNoRows) {
 			return nil, ErrResourceNotFound
 		}
+
 		return nil, fmt.Errorf("cannot query risk assessment scope authorization attributes: %w", err)
 	}
 
@@ -95,11 +97,14 @@ WHERE
 	if err != nil {
 		return fmt.Errorf("cannot query risk assessment scopes: %w", err)
 	}
+
 	results, err := pgx.CollectRows(rows, pgx.RowToAddrOfStructByName[RiskAssessmentScope])
 	if err != nil {
 		return fmt.Errorf("cannot collect risk assessment scopes: %w", err)
 	}
+
 	*ss = results
+
 	return nil
 }
 
@@ -127,6 +132,7 @@ WHERE
 	if err := conn.QueryRow(ctx, q, args).Scan(&count); err != nil {
 		return 0, fmt.Errorf("cannot count risk assessment scopes: %w", err)
 	}
+
 	return count, nil
 }
 
@@ -149,18 +155,23 @@ LIMIT 1
 	q = fmt.Sprintf(q, scope.SQLFragment())
 	args := pgx.StrictNamedArgs{"id": id}
 	maps.Copy(args, scope.SQLArguments())
+
 	rows, err := conn.Query(ctx, q, args)
 	if err != nil {
 		return fmt.Errorf("cannot query risk assessment scope: %w", err)
 	}
+
 	result, err := pgx.CollectExactlyOneRow(rows, pgx.RowToStructByName[RiskAssessmentScope])
 	if err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return ErrResourceNotFound
 		}
+
 		return fmt.Errorf("cannot collect risk assessment scope: %w", err)
 	}
+
 	*s = result
+
 	return nil
 }
 
@@ -193,10 +204,12 @@ INSERT INTO risk_assessment_scopes (
 		"created_at":         s.CreatedAt,
 		"updated_at":         s.UpdatedAt,
 	}
+
 	_, err := conn.Exec(ctx, q, args)
 	if err != nil {
 		return fmt.Errorf("cannot insert risk assessment scope: %w", err)
 	}
+
 	return nil
 }
 
@@ -213,13 +226,16 @@ WHERE
 	q = fmt.Sprintf(q, scope.SQLFragment())
 	args := pgx.StrictNamedArgs{"id": s.ID, "name": s.Name, "updated_at": s.UpdatedAt}
 	maps.Copy(args, scope.SQLArguments())
+
 	result, err := conn.Exec(ctx, q, args)
 	if err != nil {
 		return fmt.Errorf("cannot update risk assessment scope: %w", err)
 	}
+
 	if result.RowsAffected() == 0 {
 		return ErrResourceNotFound
 	}
+
 	return nil
 }
 
@@ -234,5 +250,6 @@ WHERE
 	args := pgx.StrictNamedArgs{"id": id}
 	maps.Copy(args, scope.SQLArguments())
 	_, err := conn.Exec(ctx, q, args)
+
 	return err
 }

pkg/coredata/risk_assessment_threat.go

@@ -50,6 +50,7 @@ func (t *RiskAssessmentThreat) CursorKey(orderBy RiskAssessmentThreatOrderField)
 	case RiskAssessmentThreatOrderFieldName:
 		return page.CursorKey{ID: t.ID, Value: t.Name}
 	}
+
 	panic(fmt.Sprintf("unsupported order by: %s", orderBy))
 }
 
@@ -61,6 +62,7 @@ func (t *RiskAssessmentThreat) AuthorizationAttributes(ctx context.Context, conn
 		if errors.Is(err, pgx.ErrNoRows) {
 			return nil, ErrResourceNotFound
 		}
+
 		return nil, fmt.Errorf("cannot query risk assessment threat authorization attributes: %w", err)
 	}
 
@@ -100,11 +102,14 @@ WHERE
 	if err != nil {
 		return fmt.Errorf("cannot query risk threats: %w", err)
 	}
+
 	results, err := pgx.CollectRows(rows, pgx.RowToAddrOfStructByName[RiskAssessmentThreat])
 	if err != nil {
 		return fmt.Errorf("cannot collect risk threats: %w", err)
 	}
+
 	*ts = results
+
 	return nil
 }
 
@@ -140,11 +145,14 @@ ORDER BY
 	if err != nil {
 		return fmt.Errorf("cannot query risk threats: %w", err)
 	}
+
 	results, err := pgx.CollectRows(rows, pgx.RowToAddrOfStructByName[RiskAssessmentThreat])
 	if err != nil {
 		return fmt.Errorf("cannot collect risk threats: %w", err)
 	}
+
 	*ts = results
+
 	return nil
 }
 
@@ -172,6 +180,7 @@ WHERE
 	if err := conn.QueryRow(ctx, q, args).Scan(&count); err != nil {
 		return 0, fmt.Errorf("cannot count risk threats: %w", err)
 	}
+
 	return count, nil
 }
 
@@ -196,18 +205,23 @@ LIMIT 1;
 	q = fmt.Sprintf(q, scope.SQLFragment())
 	args := pgx.StrictNamedArgs{"id": id}
 	maps.Copy(args, scope.SQLArguments())
+
 	rows, err := conn.Query(ctx, q, args)
 	if err != nil {
 		return fmt.Errorf("cannot query risk threat: %w", err)
 	}
+
 	result, err := pgx.CollectExactlyOneRow(rows, pgx.RowToStructByName[RiskAssessmentThreat])
 	if err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return ErrResourceNotFound
 		}
+
 		return fmt.Errorf("cannot collect risk threat: %w", err)
 	}
+
 	*t = result
+
 	return nil
 }
 
@@ -246,13 +260,16 @@ INSERT INTO risk_assessment_threats (
 		"created_at":               t.CreatedAt,
 		"updated_at":               t.UpdatedAt,
 	}
+
 	_, err := conn.Exec(ctx, q, args)
 	if err != nil {
 		if pgErr, ok := errors.AsType[*pgconn.PgError](err); ok && pgErr.Code == "23505" && pgErr.ConstraintName == "risk_assessment_threats_unique_name" {
 			return ErrResourceAlreadyExists
 		}
+
 		return fmt.Errorf("cannot insert risk threat: %w", err)
 	}
+
 	return nil
 }
 
@@ -277,13 +294,16 @@ WHERE
 		"updated_at": t.UpdatedAt,
 	}
 	maps.Copy(args, scope.SQLArguments())
+
 	result, err := conn.Exec(ctx, q, args)
 	if err != nil {
 		return fmt.Errorf("cannot update risk threat: %w", err)
 	}
+
 	if result.RowsAffected() == 0 {
 		return ErrResourceNotFound
 	}
+
 	return nil
 }
 
@@ -298,5 +318,6 @@ WHERE
 	args := pgx.StrictNamedArgs{"id": id}
 	maps.Copy(args, scope.SQLArguments())
 	_, err := conn.Exec(ctx, q, args)
+
 	return err
 }

pkg/riskmanagement/mermaid.go

@@ -35,12 +35,15 @@ func (s *Service) BuildScopeMermaidChart(ctx context.Context, scope coredata.Sco
 		if err := nodes.LoadAllByRiskAssessmentScopeID(ctx, conn, scope, scopeID); err != nil {
 			return fmt.Errorf("cannot load nodes: %w", err)
 		}
+
 		if err := processes.LoadAllByRiskAssessmentScopeID(ctx, conn, scope, scopeID); err != nil {
 			return fmt.Errorf("cannot load processes: %w", err)
 		}
+
 		if err := threats.LoadAllByRiskAssessmentScopeID(ctx, conn, scope, scopeID); err != nil {
 			return fmt.Errorf("cannot load threats: %w", err)
 		}
+
 		return nil
 	})
 	if err != nil {
@@ -75,10 +78,12 @@ func buildScopeMermaidChart(
 
 	for _, p := range processes {
 		src, srcOK := nodeAlias[p.SourceNodeID]
+
 		dst, dstOK := nodeAlias[p.TargetNodeID]
 		if !srcOK || !dstOK {
 			continue
 		}
+
 		fmt.Fprintf(&b, "  %s -- \"%s\" --> %s\n", src, escapeMermaidLabel(p.Name), dst)
 	}
 
@@ -92,10 +97,12 @@ func buildScopeMermaidChart(
 		if !ok {
 			continue
 		}
+
 		targetAlias, ok := nodeAlias[target]
 		if !ok {
 			continue
 		}
+
 		tid := fmt.Sprintf("t%d", i)
 		label := escapeMermaidLabel(fmt.Sprintf("%s (%s)", t.Name, t.Category))
 		fmt.Fprintf(&b, "  %s{{\"%s\"}}\n", tid, label)
@@ -114,6 +121,7 @@ func buildScopeMermaidChart(
 
 func mermaidNodeShape(t coredata.RiskAssessmentNodeType, id, name string) string {
 	label := `"` + escapeMermaidLabel(name) + `"`
+
 	switch t {
 	case coredata.RiskAssessmentNodeTypeEntity:
 		return fmt.Sprintf("%s([%s])", id, label)

pkg/server/api/connect/v1/session_resolvers.go

@@ -402,6 +402,7 @@ func (r *mutationResolver) AssumeOrganizationSession(ctx context.Context, input
 		}
 
 		r.logger.ErrorCtx(ctx, "cannot assume organization session", log.Error(err))
+
 		return nil, gqlutils.Internal(ctx)
 	}
 

pkg/server/api/console/v1/base_resolvers.go

@@ -124,60 +124,72 @@ func (r *queryResolver) Node(ctx context.Context, id gid.GID) (types.Node, error
 		action = probo.ActionRiskAssessmentGet
 		loadNode = func(ctx context.Context, id gid.GID) (types.Node, error) {
 			scope := coredata.NewScopeFromObjectID(id)
+
 			ra, err := r.riskManagement.Get(ctx, scope, id)
 			if err != nil {
 				return nil, err
 			}
+
 			return types.NewRiskAssessment(ra), nil
 		}
 	case coredata.RiskAssessmentNodeEntityType:
 		action = probo.ActionRiskAssessmentNodeGet
 		loadNode = func(ctx context.Context, id gid.GID) (types.Node, error) {
 			scope := coredata.NewScopeFromObjectID(id)
+
 			n, err := r.riskManagement.GetNode(ctx, scope, id)
 			if err != nil {
 				return nil, err
 			}
+
 			return types.NewRiskAssessmentNode(n), nil
 		}
 	case coredata.RiskAssessmentProcessEntityType:
 		action = probo.ActionRiskAssessmentProcessGet
 		loadNode = func(ctx context.Context, id gid.GID) (types.Node, error) {
 			scope := coredata.NewScopeFromObjectID(id)
+
 			p, err := r.riskManagement.GetProcess(ctx, scope, id)
 			if err != nil {
 				return nil, err
 			}
+
 			return types.NewRiskAssessmentProcess(p), nil
 		}
 	case coredata.RiskAssessmentThreatEntityType:
 		action = probo.ActionRiskAssessmentThreatGet
 		loadNode = func(ctx context.Context, id gid.GID) (types.Node, error) {
 			scope := coredata.NewScopeFromObjectID(id)
+
 			t, err := r.riskManagement.GetThreat(ctx, scope, id)
 			if err != nil {
 				return nil, err
 			}
+
 			return types.NewRiskAssessmentThreat(t), nil
 		}
 	case coredata.RiskAssessmentScopeEntityType:
 		action = probo.ActionRiskAssessmentScopeGet
 		loadNode = func(ctx context.Context, id gid.GID) (types.Node, error) {
 			scope := coredata.NewScopeFromObjectID(id)
+
 			s, err := r.riskManagement.GetScope(ctx, scope, id)
 			if err != nil {
 				return nil, err
 			}
+
 			return types.NewRiskAssessmentScope(s), nil
 		}
 	case coredata.RiskAssessmentScenarioEntityType:
 		action = probo.ActionRiskAssessmentScenarioGet
 		loadNode = func(ctx context.Context, id gid.GID) (types.Node, error) {
 			scope := coredata.NewScopeFromObjectID(id)
+
 			s, err := r.riskManagement.GetScenario(ctx, scope, id)
 			if err != nil {
 				return nil, err
 			}
+
 			return types.NewRiskAssessmentScenario(s), nil
 		}
 	case coredata.ThirdPartyComplianceReportEntityType:

pkg/server/api/console/v1/risk_assessment_resolvers.go

@@ -27,7 +27,9 @@ func (r *mutationResolver) CreateRiskAssessment(ctx context.Context, input types
 	if err := r.authorize(ctx, input.OrganizationID, probo.ActionRiskAssessmentCreate); err != nil {
 		return nil, err
 	}
+
 	scope := coredata.NewScopeFromObjectID(input.OrganizationID)
+
 	ra, err := r.riskManagement.Create(
 		ctx,
 		scope,
@@ -41,12 +43,16 @@ func (r *mutationResolver) CreateRiskAssessment(ctx context.Context, input types
 		if errors.Is(err, coredata.ErrResourceAlreadyExists) {
 			return nil, gqlutils.Conflict(ctx, err)
 		}
+
 		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
 			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
 		}
+
 		r.logger.ErrorCtx(ctx, "cannot create risk assessment", log.Error(err))
+
 		return nil, gqlutils.Internal(ctx)
 	}
+
 	return &types.CreateRiskAssessmentPayload{
 		RiskAssessmentEdge: types.NewRiskAssessmentConnectionEdge(ra, coredata.RiskAssessmentOrderFieldCreatedAt),
 	}, nil
@@ -57,7 +63,9 @@ func (r *mutationResolver) UpdateRiskAssessment(ctx context.Context, input types
 	if err := r.authorize(ctx, input.ID, probo.ActionRiskAssessmentUpdate); err != nil {
 		return nil, err
 	}
+
 	scope := coredata.NewScopeFromObjectID(input.ID)
+
 	ra, err := r.riskManagement.Update(
 		ctx,
 		scope,
@@ -71,9 +79,12 @@ func (r *mutationResolver) UpdateRiskAssessment(ctx context.Context, input types
 		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
 			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
 		}
+
 		r.logger.ErrorCtx(ctx, "cannot update risk assessment", log.Error(err))
+
 		return nil, gqlutils.Internal(ctx)
 	}
+
 	return &types.UpdateRiskAssessmentPayload{RiskAssessment: types.NewRiskAssessment(ra)}, nil
 }
 
@@ -82,14 +93,18 @@ func (r *mutationResolver) DeleteRiskAssessment(ctx context.Context, input types
 	if err := r.authorize(ctx, input.RiskAssessmentID, probo.ActionRiskAssessmentDelete); err != nil {
 		return nil, err
 	}
+
 	scope := coredata.NewScopeFromObjectID(input.RiskAssessmentID)
 	if err := r.riskManagement.Delete(ctx, scope, input.RiskAssessmentID); err != nil {
 		if errors.Is(err, coredata.ErrResourceNotFound) {
 			return nil, gqlutils.NotFound(ctx, err)
 		}
+
 		r.logger.ErrorCtx(ctx, "cannot delete risk assessment", log.Error(err))
+
 		return nil, gqlutils.Internal(ctx)
 	}
+
 	return &types.DeleteRiskAssessmentPayload{DeletedRiskAssessmentID: input.RiskAssessmentID}, nil
 }
 
@@ -98,7 +113,9 @@ func (r *mutationResolver) CreateRiskAssessmentScope(ctx context.Context, input
 	if err := r.authorize(ctx, input.RiskAssessmentID, probo.ActionRiskAssessmentScopeCreate); err != nil {
 		return nil, err
 	}
+
 	scope := coredata.NewScopeFromObjectID(input.RiskAssessmentID)
+
 	raScope, err := r.riskManagement.CreateScope(
 		ctx,
 		scope,
@@ -111,12 +128,16 @@ func (r *mutationResolver) CreateRiskAssessmentScope(ctx context.Context, input
 		if errors.Is(err, coredata.ErrResourceAlreadyExists) {
 			return nil, gqlutils.Conflict(ctx, err)
 		}
+
 		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
 			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
 		}
+
 		r.logger.ErrorCtx(ctx, "cannot create risk assessment scope", log.Error(err))
+
 		return nil, gqlutils.Internal(ctx)
 	}
+
 	return &types.CreateRiskAssessmentScopePayload{
 		RiskAssessmentScopeEdge: types.NewRiskAssessmentScopeConnectionEdge(raScope, coredata.RiskAssessmentScopeOrderFieldCreatedAt),
 	}, nil
@@ -127,7 +148,9 @@ func (r *mutationResolver) UpdateRiskAssessmentScope(ctx context.Context, input
 	if err := r.authorize(ctx, input.ID, probo.ActionRiskAssessmentScopeUpdate); err != nil {
 		return nil, err
 	}
+
 	scope := coredata.NewScopeFromObjectID(input.ID)
+
 	raScope, err := r.riskManagement.UpdateScope(
 		ctx,
 		scope,
@@ -140,9 +163,12 @@ func (r *mutationResolver) UpdateRiskAssessmentScope(ctx context.Context, input
 		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
 			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
 		}
+
 		r.logger.ErrorCtx(ctx, "cannot update risk assessment scope", log.Error(err))
+
 		return nil, gqlutils.Internal(ctx)
 	}
+
 	return &types.UpdateRiskAssessmentScopePayload{RiskAssessmentScope: types.NewRiskAssessmentScope(raScope)}, nil
 }
 
@@ -151,14 +177,18 @@ func (r *mutationResolver) DeleteRiskAssessmentScope(ctx context.Context, input
 	if err := r.authorize(ctx, input.RiskAssessmentScopeID, probo.ActionRiskAssessmentScopeDelete); err != nil {
 		return nil, err
 	}
+
 	scope := coredata.NewScopeFromObjectID(input.RiskAssessmentScopeID)
 	if err := r.riskManagement.DeleteScope(ctx, scope, input.RiskAssessmentScopeID); err != nil {
 		if errors.Is(err, coredata.ErrResourceNotFound) {
 			return nil, gqlutils.NotFound(ctx, err)
 		}
+
 		r.logger.ErrorCtx(ctx, "cannot delete risk assessment scope", log.Error(err))
+
 		return nil, gqlutils.Internal(ctx)
 	}
+
 	return &types.DeleteRiskAssessmentScopePayload{DeletedRiskAssessmentScopeID: input.RiskAssessmentScopeID}, nil
 }
 
@@ -167,7 +197,9 @@ func (r *mutationResolver) CreateRiskAssessmentNode(ctx context.Context, input t
 	if err := r.authorize(ctx, input.RiskAssessmentScopeID, probo.ActionRiskAssessmentNodeCreate); err != nil {
 		return nil, err
 	}
+
 	scope := coredata.NewScopeFromObjectID(input.RiskAssessmentScopeID)
+
 	node, err := r.riskManagement.CreateNode(
 		ctx,
 		scope,
@@ -181,12 +213,16 @@ func (r *mutationResolver) CreateRiskAssessmentNode(ctx context.Context, input t
 		if errors.Is(err, coredata.ErrResourceAlreadyExists) {
 			return nil, gqlutils.Conflict(ctx, err)
 		}
+
 		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
 			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
 		}
+
 		r.logger.ErrorCtx(ctx, "cannot create risk assessment node", log.Error(err))
+
 		return nil, gqlutils.Internal(ctx)
 	}
+
 	return &types.CreateRiskAssessmentNodePayload{
 		RiskAssessmentNodeEdge: &types.RiskAssessmentNodeConnectionEdge{
 			Cursor: node.CursorKey(coredata.RiskAssessmentNodeOrderFieldCreatedAt),
@@ -200,7 +236,9 @@ func (r *mutationResolver) UpdateRiskAssessmentNode(ctx context.Context, input t
 	if err := r.authorize(ctx, input.ID, probo.ActionRiskAssessmentNodeUpdate); err != nil {
 		return nil, err
 	}
+
 	scope := coredata.NewScopeFromObjectID(input.ID)
+
 	node, err := r.riskManagement.UpdateNode(
 		ctx,
 		scope,
@@ -214,9 +252,12 @@ func (r *mutationResolver) UpdateRiskAssessmentNode(ctx context.Context, input t
 		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
 			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
 		}
+
 		r.logger.ErrorCtx(ctx, "cannot update risk assessment node", log.Error(err))
+
 		return nil, gqlutils.Internal(ctx)
 	}
+
 	return &types.UpdateRiskAssessmentNodePayload{RiskAssessmentNode: types.NewRiskAssessmentNode(node)}, nil
 }
 
@@ -225,14 +266,18 @@ func (r *mutationResolver) DeleteRiskAssessmentNode(ctx context.Context, input t
 	if err := r.authorize(ctx, input.RiskAssessmentNodeID, probo.ActionRiskAssessmentNodeDelete); err != nil {
 		return nil, err
 	}
+
 	scope := coredata.NewScopeFromObjectID(input.RiskAssessmentNodeID)
 	if err := r.riskManagement.DeleteNode(ctx, scope, input.RiskAssessmentNodeID); err != nil {
 		if errors.Is(err, coredata.ErrResourceNotFound) {
 			return nil, gqlutils.NotFound(ctx, err)
 		}
+
 		r.logger.ErrorCtx(ctx, "cannot delete risk assessment node", log.Error(err))
+
 		return nil, gqlutils.Internal(ctx)
 	}
+
 	return &types.DeleteRiskAssessmentNodePayload{DeletedRiskAssessmentNodeID: input.RiskAssessmentNodeID}, nil
 }
 
@@ -241,7 +286,9 @@ func (r *mutationResolver) CreateRiskAssessmentProcess(ctx context.Context, inpu
 	if err := r.authorize(ctx, input.RiskAssessmentScopeID, probo.ActionRiskAssessmentProcessCreate); err != nil {
 		return nil, err
 	}
+
 	scope := coredata.NewScopeFromObjectID(input.RiskAssessmentScopeID)
+
 	process, err := r.riskManagement.CreateProcess(
 		ctx,
 		scope,
@@ -256,12 +303,16 @@ func (r *mutationResolver) CreateRiskAssessmentProcess(ctx context.Context, inpu
 		if errors.Is(err, coredata.ErrResourceAlreadyExists) {
 			return nil, gqlutils.Conflict(ctx, err)
 		}
+
 		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
 			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
 		}
+
 		r.logger.ErrorCtx(ctx, "cannot create risk assessment process", log.Error(err))
+
 		return nil, gqlutils.Internal(ctx)
 	}
+
 	return &types.CreateRiskAssessmentProcessPayload{
 		RiskAssessmentProcessEdge: &types.RiskAssessmentProcessConnectionEdge{
 			Cursor: process.CursorKey(coredata.RiskAssessmentProcessOrderFieldCreatedAt),
@@ -275,7 +326,9 @@ func (r *mutationResolver) UpdateRiskAssessmentProcess(ctx context.Context, inpu
 	if err := r.authorize(ctx, input.ID, probo.ActionRiskAssessmentProcessUpdate); err != nil {
 		return nil, err
 	}
+
 	scope := coredata.NewScopeFromObjectID(input.ID)
+
 	process, err := r.riskManagement.UpdateProcess(
 		ctx,
 		scope,
@@ -290,9 +343,12 @@ func (r *mutationResolver) UpdateRiskAssessmentProcess(ctx context.Context, inpu
 		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
 			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
 		}
+
 		r.logger.ErrorCtx(ctx, "cannot update risk assessment process", log.Error(err))
+
 		return nil, gqlutils.Internal(ctx)
 	}
+
 	return &types.UpdateRiskAssessmentProcessPayload{RiskAssessmentProcess: types.NewRiskAssessmentProcess(process)}, nil
 }
 
@@ -301,14 +357,18 @@ func (r *mutationResolver) DeleteRiskAssessmentProcess(ctx context.Context, inpu
 	if err := r.authorize(ctx, input.RiskAssessmentProcessID, probo.ActionRiskAssessmentProcessDelete); err != nil {
 		return nil, err
 	}
+
 	scope := coredata.NewScopeFromObjectID(input.RiskAssessmentProcessID)
 	if err := r.riskManagement.DeleteProcess(ctx, scope, input.RiskAssessmentProcessID); err != nil {
 		if errors.Is(err, coredata.ErrResourceNotFound) {
 			return nil, gqlutils.NotFound(ctx, err)
 		}
+
 		r.logger.ErrorCtx(ctx, "cannot delete risk assessment process", log.Error(err))
+
 		return nil, gqlutils.Internal(ctx)
 	}
+
 	return &types.DeleteRiskAssessmentProcessPayload{DeletedRiskAssessmentProcessID: input.RiskAssessmentProcessID}, nil
 }
 
@@ -317,7 +377,9 @@ func (r *mutationResolver) CreateRiskAssessmentThreat(ctx context.Context, input
 	if err := r.authorize(ctx, input.RiskAssessmentScopeID, probo.ActionRiskAssessmentThreatCreate); err != nil {
 		return nil, err
 	}
+
 	scope := coredata.NewScopeFromObjectID(input.RiskAssessmentScopeID)
+
 	threat, err := r.riskManagement.CreateThreat(
 		ctx,
 		scope,
@@ -332,12 +394,16 @@ func (r *mutationResolver) CreateRiskAssessmentThreat(ctx context.Context, input
 		if errors.Is(err, coredata.ErrResourceAlreadyExists) {
 			return nil, gqlutils.Conflict(ctx, err)
 		}
+
 		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
 			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
 		}
+
 		r.logger.ErrorCtx(ctx, "cannot create risk threat", log.Error(err))
+
 		return nil, gqlutils.Internal(ctx)
 	}
+
 	return &types.CreateRiskAssessmentThreatPayload{
 		RiskAssessmentThreatEdge: &types.RiskAssessmentThreatConnectionEdge{
 			Cursor: threat.CursorKey(coredata.RiskAssessmentThreatOrderFieldCreatedAt),
@@ -351,7 +417,9 @@ func (r *mutationResolver) UpdateRiskAssessmentThreat(ctx context.Context, input
 	if err := r.authorize(ctx, input.ID, probo.ActionRiskAssessmentThreatUpdate); err != nil {
 		return nil, err
 	}
+
 	scope := coredata.NewScopeFromObjectID(input.ID)
+
 	threat, err := r.riskManagement.UpdateThreat(
 		ctx,
 		scope,
@@ -366,9 +434,12 @@ func (r *mutationResolver) UpdateRiskAssessmentThreat(ctx context.Context, input
 		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
 			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
 		}
+
 		r.logger.ErrorCtx(ctx, "cannot update risk threat", log.Error(err))
+
 		return nil, gqlutils.Internal(ctx)
 	}
+
 	return &types.UpdateRiskAssessmentThreatPayload{RiskAssessmentThreat: types.NewRiskAssessmentThreat(threat)}, nil
 }
 
@@ -377,14 +448,18 @@ func (r *mutationResolver) DeleteRiskAssessmentThreat(ctx context.Context, input
 	if err := r.authorize(ctx, input.RiskAssessmentThreatID, probo.ActionRiskAssessmentThreatDelete); err != nil {
 		return nil, err
 	}
+
 	scope := coredata.NewScopeFromObjectID(input.RiskAssessmentThreatID)
 	if err := r.riskManagement.DeleteThreat(ctx, scope, input.RiskAssessmentThreatID); err != nil {
 		if errors.Is(err, coredata.ErrResourceNotFound) {
 			return nil, gqlutils.NotFound(ctx, err)
 		}
+
 		r.logger.ErrorCtx(ctx, "cannot delete risk threat", log.Error(err))
+
 		return nil, gqlutils.Internal(ctx)
 	}
+
 	return &types.DeleteRiskAssessmentThreatPayload{DeletedRiskAssessmentThreatID: input.RiskAssessmentThreatID}, nil
 }
 
@@ -393,7 +468,9 @@ func (r *mutationResolver) CreateRiskAssessmentScenario(ctx context.Context, inp
 	if err := r.authorize(ctx, input.RiskAssessmentScopeID, probo.ActionRiskAssessmentScenarioCreate); err != nil {
 		return nil, err
 	}
+
 	scope := coredata.NewScopeFromObjectID(input.RiskAssessmentScopeID)
+
 	scenario, err := r.riskManagement.CreateScenario(
 		ctx,
 		scope,
@@ -407,12 +484,16 @@ func (r *mutationResolver) CreateRiskAssessmentScenario(ctx context.Context, inp
 		if errors.Is(err, coredata.ErrResourceAlreadyExists) {
 			return nil, gqlutils.Conflict(ctx, err)
 		}
+
 		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
 			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
 		}
+
 		r.logger.ErrorCtx(ctx, "cannot create risk scenario", log.Error(err))
+
 		return nil, gqlutils.Internal(ctx)
 	}
+
 	return &types.CreateRiskAssessmentScenarioPayload{
 		RiskAssessmentScenarioEdge: &types.RiskAssessmentScenarioConnectionEdge{
 			Cursor: scenario.CursorKey(coredata.RiskAssessmentScenarioOrderFieldCreatedAt),
@@ -426,7 +507,9 @@ func (r *mutationResolver) UpdateRiskAssessmentScenario(ctx context.Context, inp
 	if err := r.authorize(ctx, input.ID, probo.ActionRiskAssessmentScenarioUpdate); err != nil {
 		return nil, err
 	}
+
 	scope := coredata.NewScopeFromObjectID(input.ID)
+
 	scenario, err := r.riskManagement.UpdateScenario(
 		ctx,
 		scope,
@@ -440,9 +523,12 @@ func (r *mutationResolver) UpdateRiskAssessmentScenario(ctx context.Context, inp
 		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
 			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
 		}
+
 		r.logger.ErrorCtx(ctx, "cannot update risk scenario", log.Error(err))
+
 		return nil, gqlutils.Internal(ctx)
 	}
+
 	return &types.UpdateRiskAssessmentScenarioPayload{RiskAssessmentScenario: types.NewRiskAssessmentScenario(scenario)}, nil
 }
 
@@ -451,14 +537,18 @@ func (r *mutationResolver) DeleteRiskAssessmentScenario(ctx context.Context, inp
 	if err := r.authorize(ctx, input.RiskAssessmentScenarioID, probo.ActionRiskAssessmentScenarioDelete); err != nil {
 		return nil, err
 	}
+
 	scope := coredata.NewScopeFromObjectID(input.RiskAssessmentScenarioID)
 	if err := r.riskManagement.DeleteScenario(ctx, scope, input.RiskAssessmentScenarioID); err != nil {
 		if errors.Is(err, coredata.ErrResourceNotFound) {
 			return nil, gqlutils.NotFound(ctx, err)
 		}
+
 		r.logger.ErrorCtx(ctx, "cannot delete risk scenario", log.Error(err))
+
 		return nil, gqlutils.Internal(ctx)
 	}
+
 	return &types.DeleteRiskAssessmentScenarioPayload{DeletedRiskAssessmentScenarioID: input.RiskAssessmentScenarioID}, nil
 }
 
@@ -467,6 +557,7 @@ func (r *mutationResolver) LinkRiskAssessmentScenarioThreat(ctx context.Context,
 	if err := r.authorize(ctx, input.RiskAssessmentScenarioID, probo.ActionRiskAssessmentScenarioThreatLink); err != nil {
 		return nil, err
 	}
+
 	scope := coredata.NewScopeFromObjectID(input.RiskAssessmentScenarioID)
 	if err := r.riskManagement.LinkScenarioThreat(
 		ctx,
@@ -479,17 +570,22 @@ func (r *mutationResolver) LinkRiskAssessmentScenarioThreat(ctx context.Context,
 		if errors.Is(err, coredata.ErrResourceAlreadyExists) {
 			return nil, gqlutils.Conflict(ctx, err)
 		}
+
 		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
 			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
 		}
+
 		r.logger.ErrorCtx(ctx, "cannot link risk scenario threat", log.Error(err))
+
 		return nil, gqlutils.Internal(ctx)
 	}
+
 	scenario, err := r.riskManagement.GetScenario(ctx, scope, input.RiskAssessmentScenarioID)
 	if err != nil {
 		r.logger.ErrorCtx(ctx, "cannot load risk scenario", log.Error(err))
 		return nil, gqlutils.Internal(ctx)
 	}
+
 	return &types.LinkRiskAssessmentScenarioThreatPayload{RiskAssessmentScenario: types.NewRiskAssessmentScenario(scenario)}, nil
 }
 
@@ -498,6 +594,7 @@ func (r *mutationResolver) UnlinkRiskAssessmentScenarioThreat(ctx context.Contex
 	if err := r.authorize(ctx, input.RiskAssessmentScenarioID, probo.ActionRiskAssessmentScenarioThreatUnlink); err != nil {
 		return nil, err
 	}
+
 	scope := coredata.NewScopeFromObjectID(input.RiskAssessmentScenarioID)
 	if err := r.riskManagement.UnlinkScenarioThreat(
 		ctx,
@@ -510,14 +607,18 @@ func (r *mutationResolver) UnlinkRiskAssessmentScenarioThreat(ctx context.Contex
 		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
 			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
 		}
+
 		r.logger.ErrorCtx(ctx, "cannot unlink risk scenario threat", log.Error(err))
+
 		return nil, gqlutils.Internal(ctx)
 	}
+
 	scenario, err := r.riskManagement.GetScenario(ctx, scope, input.RiskAssessmentScenarioID)
 	if err != nil {
 		r.logger.ErrorCtx(ctx, "cannot load risk scenario", log.Error(err))
 		return nil, gqlutils.Internal(ctx)
 	}
+
 	return &types.UnlinkRiskAssessmentScenarioThreatPayload{RiskAssessmentScenario: types.NewRiskAssessmentScenario(scenario)}, nil
 }
 
@@ -526,6 +627,7 @@ func (r *mutationResolver) LinkRiskAssessmentScenarioRisk(ctx context.Context, i
 	if err := r.authorize(ctx, input.RiskAssessmentScenarioID, probo.ActionRiskAssessmentScenarioRiskLink); err != nil {
 		return nil, err
 	}
+
 	scope := coredata.NewScopeFromObjectID(input.RiskAssessmentScenarioID)
 	if err := r.riskManagement.LinkScenarioRisk(
 		ctx,
@@ -538,18 +640,24 @@ func (r *mutationResolver) LinkRiskAssessmentScenarioRisk(ctx context.Context, i
 		if errors.Is(err, coredata.ErrResourceAlreadyExists) {
 			return nil, gqlutils.Conflict(ctx, err)
 		}
+
 		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
 			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
 		}
+
 		r.logger.ErrorCtx(ctx, "cannot link risk scenario risk", log.Error(err))
+
 		return nil, gqlutils.Internal(ctx)
 	}
+
 	scenario, err := r.riskManagement.GetScenario(ctx, scope, input.RiskAssessmentScenarioID)
 	if err != nil {
 		r.logger.ErrorCtx(ctx, "cannot load risk scenario", log.Error(err))
 		return nil, gqlutils.Internal(ctx)
 	}
+
 	s := types.NewRiskAssessmentScenario(scenario)
+
 	return &types.LinkRiskAssessmentScenarioRiskPayload{
 		RiskAssessmentScenario: s,
 		RiskAssessmentScenarioEdge: &types.RiskAssessmentScenarioConnectionEdge{
@@ -564,6 +672,7 @@ func (r *mutationResolver) UnlinkRiskAssessmentScenarioRisk(ctx context.Context,
 	if err := r.authorize(ctx, input.RiskAssessmentScenarioID, probo.ActionRiskAssessmentScenarioRiskUnlink); err != nil {
 		return nil, err
 	}
+
 	scope := coredata.NewScopeFromObjectID(input.RiskAssessmentScenarioID)
 	if err := r.riskManagement.UnlinkScenarioRisk(
 		ctx,
@@ -576,14 +685,18 @@ func (r *mutationResolver) UnlinkRiskAssessmentScenarioRisk(ctx context.Context,
 		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
 			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
 		}
+
 		r.logger.ErrorCtx(ctx, "cannot unlink risk scenario risk", log.Error(err))
+
 		return nil, gqlutils.Internal(ctx)
 	}
+
 	scenario, err := r.riskManagement.GetScenario(ctx, scope, input.RiskAssessmentScenarioID)
 	if err != nil {
 		r.logger.ErrorCtx(ctx, "cannot load risk scenario", log.Error(err))
 		return nil, gqlutils.Internal(ctx)
 	}
+
 	return &types.UnlinkRiskAssessmentScenarioRiskPayload{
 		RiskAssessmentScenario:          types.NewRiskAssessmentScenario(scenario),
 		DeletedRiskAssessmentScenarioID: input.RiskAssessmentScenarioID,
@@ -595,15 +708,20 @@ func (r *riskAssessmentResolver) Organization(ctx context.Context, obj *types.Ri
 	if err := r.authorize(ctx, obj.ID, probo.ActionOrganizationGet); err != nil {
 		return nil, err
 	}
+
 	loaders := dataloader.FromContext(ctx)
+
 	organization, err := loaders.Organization.Load(ctx, obj.Organization.ID)
 	if err != nil {
 		if errors.Is(err, coredata.ErrResourceNotFound) || errors.Is(err, dataloadgen.ErrNotFound) {
 			return nil, gqlutils.NotFound(ctx, err)
 		}
+
 		r.logger.ErrorCtx(ctx, "cannot get organization", log.Error(err))
+
 		return nil, gqlutils.Internal(ctx)
 	}
+
 	return types.NewOrganization(organization), nil
 }
 
@@ -612,7 +730,9 @@ func (r *riskAssessmentResolver) Scopes(ctx context.Context, obj *types.RiskAsse
 	if err := r.authorize(ctx, obj.ID, probo.ActionRiskAssessmentScopeList); err != nil {
 		return nil, err
 	}
+
 	scope := coredata.NewScopeFromObjectID(obj.ID)
+
 	pageOrderBy := page.OrderBy[coredata.RiskAssessmentScopeOrderField]{
 		Field:     coredata.RiskAssessmentScopeOrderFieldCreatedAt,
 		Direction: page.OrderDirectionDesc,
@@ -620,12 +740,15 @@ func (r *riskAssessmentResolver) Scopes(ctx context.Context, obj *types.RiskAsse
 	if orderBy != nil {
 		pageOrderBy = page.OrderBy[coredata.RiskAssessmentScopeOrderField]{Field: orderBy.Field, Direction: orderBy.Direction}
 	}
+
 	cursor := types.NewCursor(first, after, last, before, pageOrderBy)
+
 	p, err := r.riskManagement.ListScopesForRiskAssessmentID(ctx, scope, obj.ID, cursor)
 	if err != nil {
 		r.logger.ErrorCtx(ctx, "cannot list risk assessment scopes", log.Error(err))
 		return nil, gqlutils.Internal(ctx)
 	}
+
 	return types.NewRiskAssessmentScopeConnection(p, r, obj.ID), nil
 }
 
@@ -639,12 +762,15 @@ func (r *riskAssessmentConnectionResolver) TotalCount(ctx context.Context, obj *
 	if err := r.authorize(ctx, obj.ParentID, probo.ActionRiskAssessmentList); err != nil {
 		return nil, err
 	}
+
 	scope := coredata.NewScopeFromObjectID(obj.ParentID)
+
 	count, err := r.riskManagement.CountForOrganizationID(ctx, scope, obj.ParentID)
 	if err != nil {
 		r.logger.ErrorCtx(ctx, "cannot count risk assessments", log.Error(err))
 		return nil, gqlutils.Internal(ctx)
 	}
+
 	return &count, nil
 }
 
@@ -653,12 +779,15 @@ func (r *riskAssessmentNodeConnectionResolver) TotalCount(ctx context.Context, o
 	if err := r.authorize(ctx, obj.ParentID, probo.ActionRiskAssessmentNodeList); err != nil {
 		return nil, err
 	}
+
 	scope := coredata.NewScopeFromObjectID(obj.ParentID)
+
 	count, err := r.riskManagement.CountNodesForScopeID(ctx, scope, obj.ParentID)
 	if err != nil {
 		r.logger.ErrorCtx(ctx, "cannot count risk assessment nodes", log.Error(err))
 		return nil, gqlutils.Internal(ctx)
 	}
+
 	return &count, nil
 }
 
@@ -667,12 +796,15 @@ func (r *riskAssessmentProcessConnectionResolver) TotalCount(ctx context.Context
 	if err := r.authorize(ctx, obj.ParentID, probo.ActionRiskAssessmentProcessList); err != nil {
 		return nil, err
 	}
+
 	scope := coredata.NewScopeFromObjectID(obj.ParentID)
+
 	count, err := r.riskManagement.CountProcessesForScopeID(ctx, scope, obj.ParentID)
 	if err != nil {
 		r.logger.ErrorCtx(ctx, "cannot count risk assessment processes", log.Error(err))
 		return nil, gqlutils.Internal(ctx)
 	}
+
 	return &count, nil
 }
 
@@ -681,12 +813,15 @@ func (r *riskAssessmentScenarioResolver) Scope(ctx context.Context, obj *types.R
 	if err := r.authorize(ctx, obj.RiskAssessmentScopeID, probo.ActionRiskAssessmentScopeGet); err != nil {
 		return nil, err
 	}
+
 	scope := coredata.NewScopeFromObjectID(obj.RiskAssessmentScopeID)
+
 	raScope, err := r.riskManagement.GetScope(ctx, scope, obj.RiskAssessmentScopeID)
 	if err != nil {
 		r.logger.ErrorCtx(ctx, "cannot load risk assessment scope", log.Error(err))
 		return nil, gqlutils.Internal(ctx)
 	}
+
 	return types.NewRiskAssessmentScope(raScope), nil
 }
 
@@ -695,7 +830,9 @@ func (r *riskAssessmentScenarioResolver) Threats(ctx context.Context, obj *types
 	if err := r.authorize(ctx, obj.ID, probo.ActionRiskAssessmentThreatList); err != nil {
 		return nil, err
 	}
+
 	scope := coredata.NewScopeFromObjectID(obj.ID)
+
 	pageOrderBy := page.OrderBy[coredata.RiskAssessmentThreatOrderField]{
 		Field:     coredata.RiskAssessmentThreatOrderFieldCreatedAt,
 		Direction: page.OrderDirectionDesc,
@@ -703,12 +840,15 @@ func (r *riskAssessmentScenarioResolver) Threats(ctx context.Context, obj *types
 	if orderBy != nil {
 		pageOrderBy = page.OrderBy[coredata.RiskAssessmentThreatOrderField]{Field: orderBy.Field, Direction: orderBy.Direction}
 	}
+
 	cursor := types.NewCursor(first, after, last, before, pageOrderBy)
+
 	p, err := r.riskManagement.ListThreatsForScenarioID(ctx, scope, obj.ID, cursor)
 	if err != nil {
 		r.logger.ErrorCtx(ctx, "cannot list scenario threats", log.Error(err))
 		return nil, gqlutils.Internal(ctx)
 	}
+
 	return types.NewRiskAssessmentThreatConnection(p, r, obj.ID), nil
 }
 
@@ -717,7 +857,9 @@ func (r *riskAssessmentScenarioResolver) Risks(ctx context.Context, obj *types.R
 	if err := r.authorize(ctx, obj.ID, probo.ActionRiskList); err != nil {
 		return nil, err
 	}
+
 	scope := coredata.NewScopeFromObjectID(obj.ID)
+
 	pageOrderBy := page.OrderBy[coredata.RiskOrderField]{
 		Field:     coredata.RiskOrderFieldCreatedAt,
 		Direction: page.OrderDirectionDesc,
@@ -725,12 +867,15 @@ func (r *riskAssessmentScenarioResolver) Risks(ctx context.Context, obj *types.R
 	if orderBy != nil {
 		pageOrderBy = page.OrderBy[coredata.RiskOrderField]{Field: orderBy.Field, Direction: orderBy.Direction}
 	}
+
 	cursor := types.NewCursor(first, after, last, before, pageOrderBy)
+
 	p, err := r.riskManagement.ListRisksForScenarioID(ctx, scope, obj.ID, cursor)
 	if err != nil {
 		r.logger.ErrorCtx(ctx, "cannot list scenario risks", log.Error(err))
 		return nil, gqlutils.Internal(ctx)
 	}
+
 	return types.NewRiskConnection(p, r, obj.ID, nil), nil
 }
 
@@ -739,6 +884,7 @@ func (r *riskAssessmentScenarioConnectionResolver) TotalCount(ctx context.Contex
 	if err := r.authorize(ctx, obj.ParentID, probo.ActionRiskAssessmentScenarioList); err != nil {
 		return nil, err
 	}
+
 	scope := coredata.NewScopeFromObjectID(obj.ParentID)
 
 	switch obj.Resolver.(type) {
@@ -748,6 +894,7 @@ func (r *riskAssessmentScenarioConnectionResolver) TotalCount(ctx context.Contex
 			r.logger.ErrorCtx(ctx, "cannot count risk scenarios", log.Error(err))
 			return nil, gqlutils.Internal(ctx)
 		}
+
 		return &count, nil
 	case *organizationResolver:
 		count, err := r.riskManagement.CountScenariosForOrganizationID(ctx, scope, obj.ParentID)
@@ -755,6 +902,7 @@ func (r *riskAssessmentScenarioConnectionResolver) TotalCount(ctx context.Contex
 			r.logger.ErrorCtx(ctx, "cannot count risk scenarios", log.Error(err))
 			return nil, gqlutils.Internal(ctx)
 		}
+
 		return &count, nil
 	default:
 		count, err := r.riskManagement.CountScenariosForRiskID(ctx, scope, obj.ParentID)
@@ -762,6 +910,7 @@ func (r *riskAssessmentScenarioConnectionResolver) TotalCount(ctx context.Contex
 			r.logger.ErrorCtx(ctx, "cannot count risk scenarios", log.Error(err))
 			return nil, gqlutils.Internal(ctx)
 		}
+
 		return &count, nil
 	}
 }
@@ -771,7 +920,9 @@ func (r *riskAssessmentScopeResolver) Nodes(ctx context.Context, obj *types.Risk
 	if err := r.authorize(ctx, obj.ID, probo.ActionRiskAssessmentNodeList); err != nil {
 		return nil, err
 	}
+
 	scope := coredata.NewScopeFromObjectID(obj.ID)
+
 	pageOrderBy := page.OrderBy[coredata.RiskAssessmentNodeOrderField]{
 		Field:     coredata.RiskAssessmentNodeOrderFieldCreatedAt,
 		Direction: page.OrderDirectionDesc,
@@ -779,12 +930,15 @@ func (r *riskAssessmentScopeResolver) Nodes(ctx context.Context, obj *types.Risk
 	if orderBy != nil {
 		pageOrderBy = page.OrderBy[coredata.RiskAssessmentNodeOrderField]{Field: orderBy.Field, Direction: orderBy.Direction}
 	}
+
 	cursor := types.NewCursor(first, after, last, before, pageOrderBy)
+
 	p, err := r.riskManagement.ListNodesForScopeID(ctx, scope, obj.ID, cursor)
 	if err != nil {
 		r.logger.ErrorCtx(ctx, "cannot list risk assessment nodes", log.Error(err))
 		return nil, gqlutils.Internal(ctx)
 	}
+
 	return types.NewRiskAssessmentNodeConnection(p, r, obj.ID), nil
 }
 
@@ -793,7 +947,9 @@ func (r *riskAssessmentScopeResolver) Processes(ctx context.Context, obj *types.
 	if err := r.authorize(ctx, obj.ID, probo.ActionRiskAssessmentProcessList); err != nil {
 		return nil, err
 	}
+
 	scope := coredata.NewScopeFromObjectID(obj.ID)
+
 	pageOrderBy := page.OrderBy[coredata.RiskAssessmentProcessOrderField]{
 		Field:     coredata.RiskAssessmentProcessOrderFieldCreatedAt,
 		Direction: page.OrderDirectionDesc,
@@ -801,12 +957,15 @@ func (r *riskAssessmentScopeResolver) Processes(ctx context.Context, obj *types.
 	if orderBy != nil {
 		pageOrderBy = page.OrderBy[coredata.RiskAssessmentProcessOrderField]{Field: orderBy.Field, Direction: orderBy.Direction}
 	}
+
 	cursor := types.NewCursor(first, after, last, before, pageOrderBy)
+
 	p, err := r.riskManagement.ListProcessesForScopeID(ctx, scope, obj.ID, cursor)
 	if err != nil {
 		r.logger.ErrorCtx(ctx, "cannot list risk assessment processes", log.Error(err))
 		return nil, gqlutils.Internal(ctx)
 	}
+
 	return types.NewRiskAssessmentProcessConnection(p, r, obj.ID), nil
 }
 
@@ -815,7 +974,9 @@ func (r *riskAssessmentScopeResolver) Threats(ctx context.Context, obj *types.Ri
 	if err := r.authorize(ctx, obj.ID, probo.ActionRiskAssessmentThreatList); err != nil {
 		return nil, err
 	}
+
 	scope := coredata.NewScopeFromObjectID(obj.ID)
+
 	pageOrderBy := page.OrderBy[coredata.RiskAssessmentThreatOrderField]{
 		Field:     coredata.RiskAssessmentThreatOrderFieldCreatedAt,
 		Direction: page.OrderDirectionDesc,
@@ -823,12 +984,15 @@ func (r *riskAssessmentScopeResolver) Threats(ctx context.Context, obj *types.Ri
 	if orderBy != nil {
 		pageOrderBy = page.OrderBy[coredata.RiskAssessmentThreatOrderField]{Field: orderBy.Field, Direction: orderBy.Direction}
 	}
+
 	cursor := types.NewCursor(first, after, last, before, pageOrderBy)
+
 	p, err := r.riskManagement.ListThreatsForScopeID(ctx, scope, obj.ID, cursor)
 	if err != nil {
 		r.logger.ErrorCtx(ctx, "cannot list risk threats", log.Error(err))
 		return nil, gqlutils.Internal(ctx)
 	}
+
 	return types.NewRiskAssessmentThreatConnection(p, r, obj.ID), nil
 }
 
@@ -837,7 +1001,9 @@ func (r *riskAssessmentScopeResolver) Scenarios(ctx context.Context, obj *types.
 	if err := r.authorize(ctx, obj.ID, probo.ActionRiskAssessmentScenarioList); err != nil {
 		return nil, err
 	}
+
 	scope := coredata.NewScopeFromObjectID(obj.ID)
+
 	pageOrderBy := page.OrderBy[coredata.RiskAssessmentScenarioOrderField]{
 		Field:     coredata.RiskAssessmentScenarioOrderFieldCreatedAt,
 		Direction: page.OrderDirectionDesc,
@@ -845,12 +1011,15 @@ func (r *riskAssessmentScopeResolver) Scenarios(ctx context.Context, obj *types.
 	if orderBy != nil {
 		pageOrderBy = page.OrderBy[coredata.RiskAssessmentScenarioOrderField]{Field: orderBy.Field, Direction: orderBy.Direction}
 	}
+
 	cursor := types.NewCursor(first, after, last, before, pageOrderBy)
+
 	p, err := r.riskManagement.ListScenariosForScopeID(ctx, scope, obj.ID, cursor)
 	if err != nil {
 		r.logger.ErrorCtx(ctx, "cannot list risk scenarios", log.Error(err))
 		return nil, gqlutils.Internal(ctx)
 	}
+
 	return types.NewRiskAssessmentScenarioConnection(p, r, obj.ID), nil
 }
 
@@ -859,12 +1028,15 @@ func (r *riskAssessmentScopeResolver) MermaidChart(ctx context.Context, obj *typ
 	if err := r.authorize(ctx, obj.ID, probo.ActionRiskAssessmentScopeGet); err != nil {
 		return "", err
 	}
+
 	scope := coredata.NewScopeFromObjectID(obj.ID)
+
 	chart, err := r.riskManagement.BuildScopeMermaidChart(ctx, scope, obj.ID)
 	if err != nil {
 		r.logger.ErrorCtx(ctx, "cannot build risk assessment scope mermaid chart", log.Error(err))
 		return "", gqlutils.Internal(ctx)
 	}
+
 	return chart, nil
 }
 
@@ -873,12 +1045,15 @@ func (r *riskAssessmentScopeConnectionResolver) TotalCount(ctx context.Context,
 	if err := r.authorize(ctx, obj.ParentID, probo.ActionRiskAssessmentScopeList); err != nil {
 		return nil, err
 	}
+
 	scope := coredata.NewScopeFromObjectID(obj.ParentID)
+
 	count, err := r.riskManagement.CountScopesForRiskAssessmentID(ctx, scope, obj.ParentID)
 	if err != nil {
 		r.logger.ErrorCtx(ctx, "cannot count risk assessment scopes", log.Error(err))
 		return nil, gqlutils.Internal(ctx)
 	}
+
 	return &count, nil
 }
 
@@ -887,6 +1062,7 @@ func (r *riskAssessmentThreatConnectionResolver) TotalCount(ctx context.Context,
 	if err := r.authorize(ctx, obj.ParentID, probo.ActionRiskAssessmentThreatList); err != nil {
 		return nil, err
 	}
+
 	scope := coredata.NewScopeFromObjectID(obj.ParentID)
 
 	switch obj.Resolver.(type) {
@@ -896,6 +1072,7 @@ func (r *riskAssessmentThreatConnectionResolver) TotalCount(ctx context.Context,
 			r.logger.ErrorCtx(ctx, "cannot count scenario threats", log.Error(err))
 			return nil, gqlutils.Internal(ctx)
 		}
+
 		return &count, nil
 	default:
 		count, err := r.riskManagement.CountThreatsForScopeID(ctx, scope, obj.ParentID)
@@ -903,6 +1080,7 @@ func (r *riskAssessmentThreatConnectionResolver) TotalCount(ctx context.Context,
 			r.logger.ErrorCtx(ctx, "cannot count risk threats", log.Error(err))
 			return nil, gqlutils.Internal(ctx)
 		}
+
 		return &count, nil
 	}
 }

pkg/server/api/console/v1/risk_resolvers.go

@@ -463,7 +463,9 @@ func (r *riskResolver) Scenarios(ctx context.Context, obj *types.Risk, first *in
 	if err := r.authorize(ctx, obj.ID, probo.ActionRiskAssessmentScenarioList); err != nil {
 		return nil, err
 	}
+
 	scope := coredata.NewScopeFromObjectID(obj.ID)
+
 	pageOrderBy := page.OrderBy[coredata.RiskAssessmentScenarioOrderField]{
 		Field:     coredata.RiskAssessmentScenarioOrderFieldCreatedAt,
 		Direction: page.OrderDirectionDesc,
@@ -471,12 +473,15 @@ func (r *riskResolver) Scenarios(ctx context.Context, obj *types.Risk, first *in
 	if orderBy != nil {
 		pageOrderBy = page.OrderBy[coredata.RiskAssessmentScenarioOrderField]{Field: orderBy.Field, Direction: orderBy.Direction}
 	}
+
 	cursor := types.NewCursor(first, after, last, before, pageOrderBy)
+
 	p, err := r.riskManagement.ListScenariosForRiskID(ctx, scope, obj.ID, cursor)
 	if err != nil {
 		r.logger.ErrorCtx(ctx, "cannot list risk scenarios", log.Error(err))
 		return nil, gqlutils.Internal(ctx)
 	}
+
 	return types.NewRiskAssessmentScenarioConnection(p, r, obj.ID), nil
 }
 
@@ -512,11 +517,13 @@ func (r *riskConnectionResolver) TotalCount(ctx context.Context, obj *types.Risk
 		return count, nil
 	case *riskAssessmentScenarioResolver:
 		scope := coredata.NewScopeFromObjectID(obj.ParentID)
+
 		count, err := r.riskManagement.CountRisksForScenarioID(ctx, scope, obj.ParentID)
 		if err != nil {
 			r.logger.ErrorCtx(ctx, "cannot count scenario risks", log.Error(err))
 			return 0, gqlutils.Internal(ctx)
 		}
+
 		return count, nil
 	}
 

pkg/server/api/console/v1/types/risk_assessment.go

@@ -44,6 +44,7 @@ func NewRiskAssessmentConnection(
 			Node:   NewRiskAssessment(p.Data[i]),
 		}
 	}
+
 	return &RiskAssessmentConnection{
 		Edges:    edges,
 		PageInfo: *NewPageInfo(p),

pkg/server/api/console/v1/types/risk_assessment_node.go

@@ -44,6 +44,7 @@ func NewRiskAssessmentNodeConnection(
 			Node:   NewRiskAssessmentNode(p.Data[i]),
 		}
 	}
+
 	return &RiskAssessmentNodeConnection{
 		Edges:    edges,
 		PageInfo: *NewPageInfo(p),

pkg/server/api/console/v1/types/risk_assessment_process.go

@@ -44,6 +44,7 @@ func NewRiskAssessmentProcessConnection(
 			Node:   NewRiskAssessmentProcess(p.Data[i]),
 		}
 	}
+
 	return &RiskAssessmentProcessConnection{
 		Edges:    edges,
 		PageInfo: *NewPageInfo(p),

pkg/server/api/console/v1/types/risk_assessment_scenario.go

@@ -44,6 +44,7 @@ func NewRiskAssessmentScenarioConnection(
 			Node:   NewRiskAssessmentScenario(p.Data[i]),
 		}
 	}
+
 	return &RiskAssessmentScenarioConnection{
 		Edges:    edges,
 		PageInfo: *NewPageInfo(p),

pkg/server/api/console/v1/types/risk_assessment_scope.go

@@ -44,6 +44,7 @@ func NewRiskAssessmentScopeConnection(
 			Node:   NewRiskAssessmentScope(p.Data[i]),
 		}
 	}
+
 	return &RiskAssessmentScopeConnection{
 		Edges:    edges,
 		PageInfo: *NewPageInfo(p),

pkg/server/api/console/v1/types/risk_assessment_threat.go

@@ -44,6 +44,7 @@ func NewRiskAssessmentThreatConnection(
 			Node:   NewRiskAssessmentThreat(p.Data[i]),
 		}
 	}
+
 	return &RiskAssessmentThreatConnection{
 		Edges:    edges,
 		PageInfo: *NewPageInfo(p),