From d44337d0fc5df9792bd12c854661a98498034d40 Mon Sep 17 00:00:00 2001
From: Sourav Chandhok
Date: Thu, 13 Aug 2026 20:32:57 -0400
Subject: [PATCH 1/2] Build visual organization impact workflow
---
.../persistence/CatalogEdgeRepository.java | 28 +-
.../catalog/persistence/EmployeeEntity.java | 4 +-
.../shared/api/ApiExceptionHandler.java | 10 +-
.../editor/api/DraftCatalogController.java | 116 ++
.../editor/api/DraftCatalogResource.java | 73 +
.../workspace/editor/api/MemberRequest.java | 22 +
.../editor/api/QuickWorkflowRequest.java | 19 +
.../editor/api/RoleAssignmentRequest.java | 13 +
.../workspace/editor/api/RoleRequest.java | 16 +
.../workspace/editor/api/TeamRequest.java | 9 +
.../api/WorkflowRequirementRequest.java | 15 +
.../DraftCatalogConflictException.java | 8 +
.../DraftCatalogNotFoundException.java | 10 +
.../application/DraftCatalogService.java | 235 +++
.../PublishedWorkspaceMutationException.java | 8 +
.../persistence/DraftCatalogRepository.java | 507 ++++++
.../api/DraftImpactPreviewController.java | 32 +
.../api/DraftImpactPreviewRequest.java | 10 +
.../DraftImpactPreviewService.java | 45 +
.../V5__make_member_email_optional.sql | 2 +
.../V6__make_employee_number_optional.sql | 2 +
.../CatalogMigrationIntegrationTest.java | 8 +-
.../workspace/WorkspaceIntegrationTest.java | 223 +++
frontend/src/App.css | 1473 ++++++++++++++++-
frontend/src/App.test.tsx | 225 ++-
frontend/src/api/draftCatalog.ts | 153 ++
frontend/src/api/draftImpact.ts | 23 +
.../components/workspaces/DraftWorkspace.tsx | 19 +-
.../workspaces/editor/DraftEditor.tsx | 427 +++++
.../workspaces/editor/DraftImpactTesting.tsx | 202 +++
.../workspaces/editor/OrganizationCanvas.tsx | 837 ++++++++++
.../editor/WorkflowScenarioCanvas.test.ts | 43 +
.../editor/WorkflowScenarioCanvas.tsx | 128 ++
.../workspaces/editor/workflowRisks.ts | 62 +
.../editor/workflowScenarioGraph.ts | 118 ++
35 files changed, 5064 insertions(+), 61 deletions(-)
create mode 100644 backend/src/main/java/com/roleimpact/workspace/editor/api/DraftCatalogController.java
create mode 100644 backend/src/main/java/com/roleimpact/workspace/editor/api/DraftCatalogResource.java
create mode 100644 backend/src/main/java/com/roleimpact/workspace/editor/api/MemberRequest.java
create mode 100644 backend/src/main/java/com/roleimpact/workspace/editor/api/QuickWorkflowRequest.java
create mode 100644 backend/src/main/java/com/roleimpact/workspace/editor/api/RoleAssignmentRequest.java
create mode 100644 backend/src/main/java/com/roleimpact/workspace/editor/api/RoleRequest.java
create mode 100644 backend/src/main/java/com/roleimpact/workspace/editor/api/TeamRequest.java
create mode 100644 backend/src/main/java/com/roleimpact/workspace/editor/api/WorkflowRequirementRequest.java
create mode 100644 backend/src/main/java/com/roleimpact/workspace/editor/application/DraftCatalogConflictException.java
create mode 100644 backend/src/main/java/com/roleimpact/workspace/editor/application/DraftCatalogNotFoundException.java
create mode 100644 backend/src/main/java/com/roleimpact/workspace/editor/application/DraftCatalogService.java
create mode 100644 backend/src/main/java/com/roleimpact/workspace/editor/application/PublishedWorkspaceMutationException.java
create mode 100644 backend/src/main/java/com/roleimpact/workspace/editor/persistence/DraftCatalogRepository.java
create mode 100644 backend/src/main/java/com/roleimpact/workspace/preview/api/DraftImpactPreviewController.java
create mode 100644 backend/src/main/java/com/roleimpact/workspace/preview/api/DraftImpactPreviewRequest.java
create mode 100644 backend/src/main/java/com/roleimpact/workspace/preview/application/DraftImpactPreviewService.java
create mode 100644 backend/src/main/resources/db/migration/V5__make_member_email_optional.sql
create mode 100644 backend/src/main/resources/db/migration/V6__make_employee_number_optional.sql
create mode 100644 frontend/src/api/draftCatalog.ts
create mode 100644 frontend/src/api/draftImpact.ts
create mode 100644 frontend/src/components/workspaces/editor/DraftEditor.tsx
create mode 100644 frontend/src/components/workspaces/editor/DraftImpactTesting.tsx
create mode 100644 frontend/src/components/workspaces/editor/OrganizationCanvas.tsx
create mode 100644 frontend/src/components/workspaces/editor/WorkflowScenarioCanvas.test.ts
create mode 100644 frontend/src/components/workspaces/editor/WorkflowScenarioCanvas.tsx
create mode 100644 frontend/src/components/workspaces/editor/workflowRisks.ts
create mode 100644 frontend/src/components/workspaces/editor/workflowScenarioGraph.ts
diff --git a/backend/src/main/java/com/roleimpact/catalog/persistence/CatalogEdgeRepository.java b/backend/src/main/java/com/roleimpact/catalog/persistence/CatalogEdgeRepository.java
index fb8234f..bd92799 100644
--- a/backend/src/main/java/com/roleimpact/catalog/persistence/CatalogEdgeRepository.java
+++ b/backend/src/main/java/com/roleimpact/catalog/persistence/CatalogEdgeRepository.java
@@ -1,5 +1,9 @@
package com.roleimpact.catalog.persistence;
+import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.HexFormat;
import java.util.List;
import java.util.UUID;
@@ -57,7 +61,7 @@ public List findWorkflowStepConstraints(UUID organizationId) {
}
public String findContentHash(UUID organizationId, int version) {
- return jdbcClient.sql("""
+ var savedHash = jdbcClient.sql("""
SELECT content_hash
FROM organization_versions
WHERE organization_id = :organizationId AND version = :version
@@ -65,7 +69,27 @@ public String findContentHash(UUID organizationId, int version) {
.param("organizationId", organizationId)
.param("version", version)
.query(String.class)
- .single();
+ .optional();
+ if (savedHash.isPresent()) return savedHash.get();
+ if (version != 0) {
+ throw new IllegalStateException("Organization version " + version + " has no content hash");
+ }
+ String draftFingerprint = jdbcClient.sql("""
+ SELECT id::text || '|' || updated_at::text
+ FROM organizations
+ WHERE id = :organizationId AND workspace_status = 'DRAFT'
+ """).param("organizationId", organizationId).query(String.class).single();
+ return sha256(draftFingerprint);
+ }
+
+ private String sha256(String value) {
+ try {
+ return HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256")
+ .digest(value.getBytes(StandardCharsets.UTF_8)));
+ }
+ catch (NoSuchAlgorithmException exception) {
+ throw new IllegalStateException("SHA-256 is unavailable", exception);
+ }
}
private List queryEdges(String sql, UUID organizationId) {
diff --git a/backend/src/main/java/com/roleimpact/catalog/persistence/EmployeeEntity.java b/backend/src/main/java/com/roleimpact/catalog/persistence/EmployeeEntity.java
index 19a5073..bad1008 100644
--- a/backend/src/main/java/com/roleimpact/catalog/persistence/EmployeeEntity.java
+++ b/backend/src/main/java/com/roleimpact/catalog/persistence/EmployeeEntity.java
@@ -26,13 +26,13 @@ public class EmployeeEntity {
@Column(name = "team_id", nullable = false)
private UUID teamId;
- @Column(name = "employee_no", nullable = false, unique = true, length = 40)
+ @Column(name = "employee_no", unique = true, length = 40)
private String employeeNumber;
@Column(nullable = false, length = 160)
private String name;
- @Column(nullable = false, unique = true, length = 254)
+ @Column(unique = true, length = 254)
private String email;
@Enumerated(EnumType.STRING)
diff --git a/backend/src/main/java/com/roleimpact/shared/api/ApiExceptionHandler.java b/backend/src/main/java/com/roleimpact/shared/api/ApiExceptionHandler.java
index a78d9ce..0360faa 100644
--- a/backend/src/main/java/com/roleimpact/shared/api/ApiExceptionHandler.java
+++ b/backend/src/main/java/com/roleimpact/shared/api/ApiExceptionHandler.java
@@ -13,6 +13,9 @@
import com.roleimpact.workspace.application.WorkspaceConflictException;
import com.roleimpact.workspace.application.WorkspaceNotFoundException;
import com.roleimpact.workspace.application.WorkspaceValidationException;
+import com.roleimpact.workspace.editor.application.DraftCatalogConflictException;
+import com.roleimpact.workspace.editor.application.DraftCatalogNotFoundException;
+import com.roleimpact.workspace.editor.application.PublishedWorkspaceMutationException;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
@@ -26,7 +29,7 @@ public class ApiExceptionHandler {
@ExceptionHandler({OrganizationNotFoundException.class, ImpactEntityNotFoundException.class,
RecommendationNotFoundException.class, SimulationNotFoundException.class,
- WorkspaceNotFoundException.class})
+ WorkspaceNotFoundException.class, DraftCatalogNotFoundException.class})
ResponseEntity handleNotFound(RuntimeException exception) {
return error(HttpStatus.NOT_FOUND, "ENTITY_NOT_FOUND", exception.getMessage(), List.of());
}
@@ -51,6 +54,11 @@ ResponseEntity handleWorkspaceConflict(WorkspaceConflictException
return error(HttpStatus.CONFLICT, "WORKSPACE_CONFLICT", exception.getMessage(), List.of());
}
+ @ExceptionHandler({DraftCatalogConflictException.class, PublishedWorkspaceMutationException.class})
+ ResponseEntity handleDraftCatalogConflict(RuntimeException exception) {
+ return error(HttpStatus.CONFLICT, "DRAFT_CATALOG_CONFLICT", exception.getMessage(), List.of());
+ }
+
@ExceptionHandler(MethodArgumentNotValidException.class)
ResponseEntity handleValidation(MethodArgumentNotValidException exception) {
var fieldErrors = exception.getBindingResult().getFieldErrors().stream()
diff --git a/backend/src/main/java/com/roleimpact/workspace/editor/api/DraftCatalogController.java b/backend/src/main/java/com/roleimpact/workspace/editor/api/DraftCatalogController.java
new file mode 100644
index 0000000..493c564
--- /dev/null
+++ b/backend/src/main/java/com/roleimpact/workspace/editor/api/DraftCatalogController.java
@@ -0,0 +1,116 @@
+package com.roleimpact.workspace.editor.api;
+
+import java.util.UUID;
+
+import com.roleimpact.workspace.editor.application.DraftCatalogService;
+
+import jakarta.validation.Valid;
+
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/api/v1/workspaces/{workspaceId}/catalog")
+public class DraftCatalogController {
+
+ private final DraftCatalogService service;
+
+ public DraftCatalogController(DraftCatalogService service) {
+ this.service = service;
+ }
+
+ @GetMapping
+ public DraftCatalogResource get(@PathVariable UUID workspaceId) {
+ return service.get(workspaceId);
+ }
+
+ @PostMapping("/teams")
+ public DraftCatalogResource createTeam(
+ @PathVariable UUID workspaceId,
+ @Valid @RequestBody TeamRequest request) {
+ return service.createTeam(workspaceId, request);
+ }
+
+ @PutMapping("/teams/{teamId}")
+ public DraftCatalogResource updateTeam(@PathVariable UUID workspaceId, @PathVariable UUID teamId,
+ @Valid @RequestBody TeamRequest request) {
+ return service.updateTeam(workspaceId, teamId, request);
+ }
+
+ @DeleteMapping("/teams/{teamId}")
+ public DraftCatalogResource deleteTeam(@PathVariable UUID workspaceId, @PathVariable UUID teamId) {
+ return service.deleteTeam(workspaceId, teamId);
+ }
+
+ @PostMapping("/members")
+ public DraftCatalogResource createMember(
+ @PathVariable UUID workspaceId,
+ @Valid @RequestBody MemberRequest request) {
+ return service.createMember(workspaceId, request);
+ }
+
+ @PutMapping("/members/{memberId}")
+ public DraftCatalogResource updateMember(@PathVariable UUID workspaceId, @PathVariable UUID memberId,
+ @Valid @RequestBody MemberRequest request) {
+ return service.updateMember(workspaceId, memberId, request);
+ }
+
+ @DeleteMapping("/members/{memberId}")
+ public DraftCatalogResource deleteMember(@PathVariable UUID workspaceId, @PathVariable UUID memberId) {
+ return service.deleteMember(workspaceId, memberId);
+ }
+
+ @PostMapping("/roles")
+ public DraftCatalogResource createRole(
+ @PathVariable UUID workspaceId,
+ @Valid @RequestBody RoleRequest request) {
+ return service.createRole(workspaceId, request);
+ }
+
+ @PutMapping("/roles/{roleId}")
+ public DraftCatalogResource updateRole(@PathVariable UUID workspaceId, @PathVariable UUID roleId,
+ @Valid @RequestBody RoleRequest request) {
+ return service.updateRole(workspaceId, roleId, request);
+ }
+
+ @DeleteMapping("/roles/{roleId}")
+ public DraftCatalogResource deleteRole(@PathVariable UUID workspaceId, @PathVariable UUID roleId) {
+ return service.deleteRole(workspaceId, roleId);
+ }
+
+ @PutMapping("/members/{memberId}/roles")
+ public DraftCatalogResource replaceMemberRoles(
+ @PathVariable UUID workspaceId,
+ @PathVariable UUID memberId,
+ @Valid @RequestBody RoleAssignmentRequest request) {
+ return service.replaceMemberRoles(workspaceId, memberId, request);
+ }
+
+ @PostMapping("/workflows/quick")
+ public DraftCatalogResource createQuickWorkflow(
+ @PathVariable UUID workspaceId,
+ @Valid @RequestBody QuickWorkflowRequest request) {
+ return service.createQuickWorkflow(workspaceId, request);
+ }
+
+ @PostMapping("/workflows/{workflowId}/requirements")
+ public DraftCatalogResource addWorkflowRequirement(
+ @PathVariable UUID workspaceId,
+ @PathVariable UUID workflowId,
+ @Valid @RequestBody WorkflowRequirementRequest request) {
+ return service.addWorkflowRequirement(workspaceId, workflowId, request);
+ }
+
+ @DeleteMapping("/workflows/{workflowId}")
+ public DraftCatalogResource deleteWorkflow(
+ @PathVariable UUID workspaceId,
+ @PathVariable UUID workflowId) {
+ return service.deleteWorkflow(workspaceId, workflowId);
+ }
+}
diff --git a/backend/src/main/java/com/roleimpact/workspace/editor/api/DraftCatalogResource.java b/backend/src/main/java/com/roleimpact/workspace/editor/api/DraftCatalogResource.java
new file mode 100644
index 0000000..0faa775
--- /dev/null
+++ b/backend/src/main/java/com/roleimpact/workspace/editor/api/DraftCatalogResource.java
@@ -0,0 +1,73 @@
+package com.roleimpact.workspace.editor.api;
+
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+
+public record DraftCatalogResource(
+ UUID workspaceId,
+ List teams,
+ List members,
+ List roles,
+ List workflows) {
+
+ public DraftCatalogResource {
+ teams = List.copyOf(teams);
+ members = List.copyOf(members);
+ roles = List.copyOf(roles);
+ workflows = List.copyOf(workflows);
+ }
+
+ public record TeamItem(UUID id, String name, String department, int memberCount) {
+ }
+
+ public record MemberItem(
+ UUID id,
+ UUID teamId,
+ String employeeNumber,
+ String name,
+ String email,
+ String status,
+ String region,
+ String shift,
+ Set roleIds) {
+ public MemberItem {
+ roleIds = Set.copyOf(roleIds);
+ }
+ }
+
+ public record RoleItem(
+ UUID id,
+ String name,
+ String description,
+ String sensitivity,
+ UUID ownerMemberId,
+ int memberCount) {
+ }
+
+ public record WorkflowItem(
+ UUID id,
+ String name,
+ String criticality,
+ List requirements,
+ boolean quickManaged) {
+ public WorkflowItem {
+ requirements = List.copyOf(requirements);
+ }
+ }
+
+ public record WorkflowRequirementItem(
+ UUID id,
+ String name,
+ int position,
+ int minimumActors,
+ int resilienceTarget,
+ String requiredDepartment,
+ String requiredRegion,
+ String requiredShift,
+ Set roleIds) {
+ public WorkflowRequirementItem {
+ roleIds = Set.copyOf(roleIds);
+ }
+ }
+}
diff --git a/backend/src/main/java/com/roleimpact/workspace/editor/api/MemberRequest.java b/backend/src/main/java/com/roleimpact/workspace/editor/api/MemberRequest.java
new file mode 100644
index 0000000..48f6c39
--- /dev/null
+++ b/backend/src/main/java/com/roleimpact/workspace/editor/api/MemberRequest.java
@@ -0,0 +1,22 @@
+package com.roleimpact.workspace.editor.api;
+
+import java.util.UUID;
+
+import com.roleimpact.shared.model.EmployeeStatus;
+import com.roleimpact.shared.model.Region;
+import com.roleimpact.shared.model.WorkShift;
+
+import jakarta.validation.constraints.Email;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Size;
+
+public record MemberRequest(
+ @NotNull UUID teamId,
+ @Size(max = 40) String employeeNumber,
+ @NotBlank @Size(max = 160) String name,
+ @Email @Size(max = 254) String email,
+ @NotNull EmployeeStatus status,
+ @NotNull Region region,
+ @NotNull WorkShift shift) {
+}
diff --git a/backend/src/main/java/com/roleimpact/workspace/editor/api/QuickWorkflowRequest.java b/backend/src/main/java/com/roleimpact/workspace/editor/api/QuickWorkflowRequest.java
new file mode 100644
index 0000000..f0d1328
--- /dev/null
+++ b/backend/src/main/java/com/roleimpact/workspace/editor/api/QuickWorkflowRequest.java
@@ -0,0 +1,19 @@
+package com.roleimpact.workspace.editor.api;
+
+import java.util.UUID;
+
+import com.roleimpact.shared.model.WorkflowCriticality;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Min;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Size;
+
+public record QuickWorkflowRequest(
+ @NotBlank @Size(max = 160) String name,
+ @NotNull WorkflowCriticality criticality,
+ @NotBlank @Size(max = 160) String requirementName,
+ @NotNull UUID roleId,
+ @Min(1) int minimumActors,
+ @Min(1) int resilienceTarget) {
+}
diff --git a/backend/src/main/java/com/roleimpact/workspace/editor/api/RoleAssignmentRequest.java b/backend/src/main/java/com/roleimpact/workspace/editor/api/RoleAssignmentRequest.java
new file mode 100644
index 0000000..fc5396a
--- /dev/null
+++ b/backend/src/main/java/com/roleimpact/workspace/editor/api/RoleAssignmentRequest.java
@@ -0,0 +1,13 @@
+package com.roleimpact.workspace.editor.api;
+
+import java.util.Set;
+import java.util.UUID;
+
+import jakarta.validation.constraints.NotNull;
+
+public record RoleAssignmentRequest(@NotNull Set roleIds) {
+
+ public RoleAssignmentRequest {
+ roleIds = roleIds == null ? null : Set.copyOf(roleIds);
+ }
+}
diff --git a/backend/src/main/java/com/roleimpact/workspace/editor/api/RoleRequest.java b/backend/src/main/java/com/roleimpact/workspace/editor/api/RoleRequest.java
new file mode 100644
index 0000000..d70f11f
--- /dev/null
+++ b/backend/src/main/java/com/roleimpact/workspace/editor/api/RoleRequest.java
@@ -0,0 +1,16 @@
+package com.roleimpact.workspace.editor.api;
+
+import java.util.UUID;
+
+import com.roleimpact.shared.model.Sensitivity;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Size;
+
+public record RoleRequest(
+ @NotBlank @Size(max = 120) String name,
+ @NotBlank @Size(max = 2000) String description,
+ @NotNull Sensitivity sensitivity,
+ UUID ownerMemberId) {
+}
diff --git a/backend/src/main/java/com/roleimpact/workspace/editor/api/TeamRequest.java b/backend/src/main/java/com/roleimpact/workspace/editor/api/TeamRequest.java
new file mode 100644
index 0000000..d0f2f64
--- /dev/null
+++ b/backend/src/main/java/com/roleimpact/workspace/editor/api/TeamRequest.java
@@ -0,0 +1,9 @@
+package com.roleimpact.workspace.editor.api;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Size;
+
+public record TeamRequest(
+ @NotBlank @Size(max = 120) String name,
+ @NotBlank @Size(max = 120) String department) {
+}
diff --git a/backend/src/main/java/com/roleimpact/workspace/editor/api/WorkflowRequirementRequest.java b/backend/src/main/java/com/roleimpact/workspace/editor/api/WorkflowRequirementRequest.java
new file mode 100644
index 0000000..624dee9
--- /dev/null
+++ b/backend/src/main/java/com/roleimpact/workspace/editor/api/WorkflowRequirementRequest.java
@@ -0,0 +1,15 @@
+package com.roleimpact.workspace.editor.api;
+
+import java.util.UUID;
+
+import jakarta.validation.constraints.Min;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Size;
+
+public record WorkflowRequirementRequest(
+ @NotBlank @Size(max = 160) String name,
+ @NotNull UUID roleId,
+ @Min(1) int minimumActors,
+ @Min(1) int resilienceTarget) {
+}
diff --git a/backend/src/main/java/com/roleimpact/workspace/editor/application/DraftCatalogConflictException.java b/backend/src/main/java/com/roleimpact/workspace/editor/application/DraftCatalogConflictException.java
new file mode 100644
index 0000000..1625979
--- /dev/null
+++ b/backend/src/main/java/com/roleimpact/workspace/editor/application/DraftCatalogConflictException.java
@@ -0,0 +1,8 @@
+package com.roleimpact.workspace.editor.application;
+
+public class DraftCatalogConflictException extends RuntimeException {
+
+ public DraftCatalogConflictException(String message) {
+ super(message);
+ }
+}
diff --git a/backend/src/main/java/com/roleimpact/workspace/editor/application/DraftCatalogNotFoundException.java b/backend/src/main/java/com/roleimpact/workspace/editor/application/DraftCatalogNotFoundException.java
new file mode 100644
index 0000000..0bdd2ff
--- /dev/null
+++ b/backend/src/main/java/com/roleimpact/workspace/editor/application/DraftCatalogNotFoundException.java
@@ -0,0 +1,10 @@
+package com.roleimpact.workspace.editor.application;
+
+import java.util.UUID;
+
+public class DraftCatalogNotFoundException extends RuntimeException {
+
+ public DraftCatalogNotFoundException(String entity, UUID id) {
+ super(entity + " not found in this workspace: " + id);
+ }
+}
diff --git a/backend/src/main/java/com/roleimpact/workspace/editor/application/DraftCatalogService.java b/backend/src/main/java/com/roleimpact/workspace/editor/application/DraftCatalogService.java
new file mode 100644
index 0000000..c70a4dc
--- /dev/null
+++ b/backend/src/main/java/com/roleimpact/workspace/editor/application/DraftCatalogService.java
@@ -0,0 +1,235 @@
+package com.roleimpact.workspace.editor.application;
+
+import java.util.Set;
+import java.util.UUID;
+import java.util.function.Supplier;
+
+import com.roleimpact.workspace.application.WorkspaceNotFoundException;
+import com.roleimpact.workspace.editor.api.DraftCatalogResource;
+import com.roleimpact.workspace.editor.api.MemberRequest;
+import com.roleimpact.workspace.editor.api.RoleAssignmentRequest;
+import com.roleimpact.workspace.editor.api.RoleRequest;
+import com.roleimpact.workspace.editor.api.TeamRequest;
+import com.roleimpact.workspace.editor.api.QuickWorkflowRequest;
+import com.roleimpact.workspace.editor.api.WorkflowRequirementRequest;
+import com.roleimpact.workspace.editor.persistence.DraftCatalogRepository;
+
+import org.springframework.dao.DataIntegrityViolationException;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+public class DraftCatalogService {
+
+ private final DraftCatalogRepository repository;
+
+ public DraftCatalogService(DraftCatalogRepository repository) {
+ this.repository = repository;
+ }
+
+ @Transactional(readOnly = true)
+ public DraftCatalogResource get(UUID workspaceId) {
+ requireWorkspace(workspaceId);
+ return repository.findCatalog(workspaceId);
+ }
+
+ @Transactional
+ public DraftCatalogResource createTeam(UUID workspaceId, TeamRequest request) {
+ requireDraft(workspaceId);
+ mutate(() -> repository.insertTeam(workspaceId, request), "A team with this name already exists");
+ touch(workspaceId);
+ return repository.findCatalog(workspaceId);
+ }
+
+ @Transactional
+ public DraftCatalogResource deleteTeam(UUID workspaceId, UUID teamId) {
+ requireDraft(workspaceId);
+ requireTeam(workspaceId, teamId);
+ if (repository.countTeamMembers(workspaceId, teamId) > 0) {
+ throw new DraftCatalogConflictException("Move or remove this team's members before deleting the team");
+ }
+ repository.deleteTeam(workspaceId, teamId);
+ touch(workspaceId);
+ return repository.findCatalog(workspaceId);
+ }
+
+ @Transactional
+ public DraftCatalogResource updateTeam(UUID workspaceId, UUID teamId, TeamRequest request) {
+ requireDraft(workspaceId);
+ requireTeam(workspaceId, teamId);
+ mutate(() -> { repository.updateTeam(workspaceId, teamId, request); return teamId; },
+ "A team with this name already exists");
+ touch(workspaceId);
+ return repository.findCatalog(workspaceId);
+ }
+
+ @Transactional
+ public DraftCatalogResource createMember(UUID workspaceId, MemberRequest request) {
+ requireDraft(workspaceId);
+ requireTeam(workspaceId, request.teamId());
+ mutate(() -> repository.insertMember(workspaceId, request),
+ "Employee number and email must be unique within this workspace");
+ touch(workspaceId);
+ return repository.findCatalog(workspaceId);
+ }
+
+ @Transactional
+ public DraftCatalogResource deleteMember(UUID workspaceId, UUID memberId) {
+ requireDraft(workspaceId);
+ requireMember(workspaceId, memberId);
+ repository.deleteMember(workspaceId, memberId);
+ touch(workspaceId);
+ return repository.findCatalog(workspaceId);
+ }
+
+ @Transactional
+ public DraftCatalogResource updateMember(UUID workspaceId, UUID memberId, MemberRequest request) {
+ requireDraft(workspaceId);
+ requireMember(workspaceId, memberId);
+ requireTeam(workspaceId, request.teamId());
+ mutate(() -> { repository.updateMember(workspaceId, memberId, request); return memberId; },
+ "Employee number and email must be unique within this workspace");
+ touch(workspaceId);
+ return repository.findCatalog(workspaceId);
+ }
+
+ @Transactional
+ public DraftCatalogResource createRole(UUID workspaceId, RoleRequest request) {
+ requireDraft(workspaceId);
+ if (request.ownerMemberId() != null) requireMember(workspaceId, request.ownerMemberId());
+ mutate(() -> repository.insertRole(workspaceId, request), "A role with this name already exists");
+ touch(workspaceId);
+ return repository.findCatalog(workspaceId);
+ }
+
+ @Transactional
+ public DraftCatalogResource deleteRole(UUID workspaceId, UUID roleId) {
+ requireDraft(workspaceId);
+ requireRole(workspaceId, roleId);
+ if (repository.countWorkflowsForRole(workspaceId, roleId) > 0) {
+ throw new DraftCatalogConflictException("Delete or reconfigure workflows that depend on this role first");
+ }
+ repository.deleteRole(workspaceId, roleId);
+ touch(workspaceId);
+ return repository.findCatalog(workspaceId);
+ }
+
+ @Transactional
+ public DraftCatalogResource updateRole(UUID workspaceId, UUID roleId, RoleRequest request) {
+ requireDraft(workspaceId);
+ requireRole(workspaceId, roleId);
+ if (request.ownerMemberId() != null) requireMember(workspaceId, request.ownerMemberId());
+ mutate(() -> { repository.updateRole(workspaceId, roleId, request); return roleId; },
+ "A role with this name already exists");
+ touch(workspaceId);
+ return repository.findCatalog(workspaceId);
+ }
+
+ @Transactional
+ public DraftCatalogResource replaceMemberRoles(
+ UUID workspaceId,
+ UUID memberId,
+ RoleAssignmentRequest request) {
+ requireDraft(workspaceId);
+ requireMember(workspaceId, memberId);
+ Set roleIds = request.roleIds();
+ if (repository.countMatchingRoles(workspaceId, roleIds) != roleIds.size()) {
+ throw new DraftCatalogNotFoundException("Role", roleIds.stream()
+ .filter(roleId -> !repository.roleExists(workspaceId, roleId))
+ .findFirst().orElseThrow());
+ }
+ repository.replaceAssignments(memberId, roleIds);
+ touch(workspaceId);
+ return repository.findCatalog(workspaceId);
+ }
+
+ @Transactional
+ public DraftCatalogResource createQuickWorkflow(UUID workspaceId, QuickWorkflowRequest request) {
+ requireDraft(workspaceId);
+ requireRole(workspaceId, request.roleId());
+ requireCoverage(request.minimumActors(), request.resilienceTarget());
+ mutate(() -> repository.insertQuickWorkflow(workspaceId, request),
+ "This workflow already exists. Open it and add another role requirement instead");
+ touch(workspaceId);
+ return repository.findCatalog(workspaceId);
+ }
+
+ @Transactional
+ public DraftCatalogResource addWorkflowRequirement(
+ UUID workspaceId,
+ UUID workflowId,
+ WorkflowRequirementRequest request) {
+ requireDraft(workspaceId);
+ if (!repository.workflowExists(workspaceId, workflowId)) {
+ throw new DraftCatalogNotFoundException("Workflow", workflowId);
+ }
+ if (!repository.quickWorkflowExists(workspaceId, workflowId)) {
+ throw new DraftCatalogConflictException("The example workflow is read-only for now; clone its pattern into a custom workflow to edit requirements");
+ }
+ requireRole(workspaceId, request.roleId());
+ requireCoverage(request.minimumActors(), request.resilienceTarget());
+ mutate(() -> repository.insertWorkflowRequirement(workspaceId, workflowId, request),
+ "This responsibility already exists in the workflow");
+ touch(workspaceId);
+ return repository.findCatalog(workspaceId);
+ }
+
+ @Transactional
+ public DraftCatalogResource deleteWorkflow(UUID workspaceId, UUID workflowId) {
+ requireDraft(workspaceId);
+ if (!repository.workflowExists(workspaceId, workflowId)) {
+ throw new DraftCatalogNotFoundException("Workflow", workflowId);
+ }
+ repository.deleteWorkflow(workspaceId, workflowId);
+ touch(workspaceId);
+ return repository.findCatalog(workspaceId);
+ }
+
+ private void requireWorkspace(UUID workspaceId) {
+ repository.findWorkspaceStatus(workspaceId)
+ .orElseThrow(() -> new WorkspaceNotFoundException(workspaceId));
+ }
+
+ private void requireDraft(UUID workspaceId) {
+ String status = repository.findWorkspaceStatus(workspaceId)
+ .orElseThrow(() -> new WorkspaceNotFoundException(workspaceId));
+ if (!"DRAFT".equals(status)) throw new PublishedWorkspaceMutationException();
+ }
+
+ private void requireTeam(UUID workspaceId, UUID teamId) {
+ if (!repository.teamExists(workspaceId, teamId)) {
+ throw new DraftCatalogNotFoundException("Team", teamId);
+ }
+ }
+
+ private void requireMember(UUID workspaceId, UUID memberId) {
+ if (!repository.memberExists(workspaceId, memberId)) {
+ throw new DraftCatalogNotFoundException("Member", memberId);
+ }
+ }
+
+ private void requireRole(UUID workspaceId, UUID roleId) {
+ if (!repository.roleExists(workspaceId, roleId)) {
+ throw new DraftCatalogNotFoundException("Role", roleId);
+ }
+ }
+
+ private void requireCoverage(int minimumActors, int resilienceTarget) {
+ if (resilienceTarget < minimumActors) {
+ throw new DraftCatalogConflictException("Healthy coverage cannot be lower than the minimum people required");
+ }
+ }
+
+ private void mutate(Supplier mutation, String conflictMessage) {
+ try {
+ mutation.get();
+ }
+ catch (DataIntegrityViolationException exception) {
+ throw new DraftCatalogConflictException(conflictMessage);
+ }
+ }
+
+ private void touch(UUID workspaceId) {
+ repository.touchWorkspace(workspaceId);
+ }
+}
diff --git a/backend/src/main/java/com/roleimpact/workspace/editor/application/PublishedWorkspaceMutationException.java b/backend/src/main/java/com/roleimpact/workspace/editor/application/PublishedWorkspaceMutationException.java
new file mode 100644
index 0000000..8e6577e
--- /dev/null
+++ b/backend/src/main/java/com/roleimpact/workspace/editor/application/PublishedWorkspaceMutationException.java
@@ -0,0 +1,8 @@
+package com.roleimpact.workspace.editor.application;
+
+public class PublishedWorkspaceMutationException extends RuntimeException {
+
+ public PublishedWorkspaceMutationException() {
+ super("Published workspaces are immutable; clone this workspace before editing it");
+ }
+}
diff --git a/backend/src/main/java/com/roleimpact/workspace/editor/persistence/DraftCatalogRepository.java b/backend/src/main/java/com/roleimpact/workspace/editor/persistence/DraftCatalogRepository.java
new file mode 100644
index 0000000..69f915e
--- /dev/null
+++ b/backend/src/main/java/com/roleimpact/workspace/editor/persistence/DraftCatalogRepository.java
@@ -0,0 +1,507 @@
+package com.roleimpact.workspace.editor.persistence;
+
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
+
+import com.roleimpact.workspace.editor.api.DraftCatalogResource;
+import com.roleimpact.workspace.editor.api.DraftCatalogResource.MemberItem;
+import com.roleimpact.workspace.editor.api.DraftCatalogResource.RoleItem;
+import com.roleimpact.workspace.editor.api.DraftCatalogResource.TeamItem;
+import com.roleimpact.workspace.editor.api.DraftCatalogResource.WorkflowRequirementItem;
+import com.roleimpact.workspace.editor.api.MemberRequest;
+import com.roleimpact.workspace.editor.api.RoleRequest;
+import com.roleimpact.workspace.editor.api.TeamRequest;
+import com.roleimpact.workspace.editor.api.QuickWorkflowRequest;
+import com.roleimpact.workspace.editor.api.WorkflowRequirementRequest;
+import com.roleimpact.workspace.editor.api.DraftCatalogResource.WorkflowItem;
+
+import org.springframework.jdbc.core.simple.JdbcClient;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public class DraftCatalogRepository {
+
+ private final JdbcClient jdbcClient;
+
+ public DraftCatalogRepository(JdbcClient jdbcClient) {
+ this.jdbcClient = jdbcClient;
+ }
+
+ public Optional findWorkspaceStatus(UUID workspaceId) {
+ return jdbcClient.sql("SELECT workspace_status FROM organizations WHERE id = :workspaceId")
+ .param("workspaceId", workspaceId)
+ .query(String.class)
+ .optional();
+ }
+
+ public DraftCatalogResource findCatalog(UUID workspaceId) {
+ List teams = jdbcClient.sql("""
+ SELECT t.id, t.name, t.department, COUNT(e.id) AS member_count
+ FROM teams t
+ LEFT JOIN employees e ON e.team_id = t.id
+ WHERE t.organization_id = :workspaceId
+ GROUP BY t.id, t.name, t.department
+ ORDER BY t.name, t.id
+ """).param("workspaceId", workspaceId)
+ .query((rs, row) -> new TeamItem(
+ rs.getObject("id", UUID.class), rs.getString("name"),
+ rs.getString("department"), rs.getInt("member_count")))
+ .list();
+
+ Map> assignments = new LinkedHashMap<>();
+ jdbcClient.sql("""
+ SELECT er.employee_id, er.role_id
+ FROM employee_roles er
+ JOIN employees e ON e.id = er.employee_id
+ WHERE e.organization_id = :workspaceId
+ ORDER BY er.employee_id, er.role_id
+ """).param("workspaceId", workspaceId)
+ .query((rs, row) -> new Assignment(
+ rs.getObject("employee_id", UUID.class), rs.getObject("role_id", UUID.class)))
+ .list()
+ .forEach(assignment -> assignments
+ .computeIfAbsent(assignment.memberId(), ignored -> new LinkedHashSet<>())
+ .add(assignment.roleId()));
+
+ List members = jdbcClient.sql("""
+ SELECT id, team_id, employee_no, name, email, status, region, shift
+ FROM employees
+ WHERE organization_id = :workspaceId
+ ORDER BY name, id
+ """).param("workspaceId", workspaceId)
+ .query((rs, row) -> {
+ UUID id = rs.getObject("id", UUID.class);
+ return new MemberItem(
+ id,
+ rs.getObject("team_id", UUID.class),
+ rs.getString("employee_no"),
+ rs.getString("name"),
+ rs.getString("email"),
+ rs.getString("status"),
+ rs.getString("region"),
+ rs.getString("shift"),
+ assignments.getOrDefault(id, Set.of()));
+ })
+ .list();
+
+ List roles = jdbcClient.sql("""
+ SELECT r.id, r.name, r.description, r.sensitivity, r.owner_employee_id,
+ COUNT(er.employee_id) AS member_count
+ FROM roles r
+ LEFT JOIN employee_roles er ON er.role_id = r.id
+ WHERE r.organization_id = :workspaceId
+ GROUP BY r.id, r.name, r.description, r.sensitivity, r.owner_employee_id
+ ORDER BY r.name, r.id
+ """).param("workspaceId", workspaceId)
+ .query((rs, row) -> new RoleItem(
+ rs.getObject("id", UUID.class),
+ rs.getString("name"),
+ rs.getString("description"),
+ rs.getString("sensitivity"),
+ rs.getObject("owner_employee_id", UUID.class),
+ rs.getInt("member_count")))
+ .list();
+
+ List workflowRows = jdbcClient.sql("""
+ SELECT w.id AS workflow_id, w.name AS workflow_name, w.criticality,
+ ws.id AS step_id, ws.name AS step_name, ws.position,
+ ws.minimum_actors, ws.resilience_target, ws.required_department,
+ ws.required_region, ws.required_shift, rp.role_id,
+ COALESCE(a.category = 'Business Workflow', FALSE) AS quick_managed
+ FROM workflows w
+ LEFT JOIN workflow_steps ws ON ws.workflow_id = w.id
+ LEFT JOIN applications a ON a.id = ws.required_application_id
+ LEFT JOIN capability_permissions cp ON cp.capability_id = ws.required_capability_id
+ LEFT JOIN role_permissions rp ON rp.permission_id = cp.permission_id
+ WHERE w.organization_id = :workspaceId
+ ORDER BY w.name, w.id, ws.position, ws.id, rp.role_id
+ """).param("workspaceId", workspaceId)
+ .query((rs, row) -> new WorkflowRow(
+ rs.getObject("workflow_id", UUID.class), rs.getString("workflow_name"),
+ rs.getString("criticality"), rs.getObject("step_id", UUID.class),
+ rs.getString("step_name"), rs.getInt("position"),
+ rs.getInt("minimum_actors"), rs.getInt("resilience_target"),
+ rs.getString("required_department"), rs.getString("required_region"),
+ rs.getString("required_shift"), rs.getObject("role_id", UUID.class),
+ rs.getBoolean("quick_managed")))
+ .list();
+ Map workflowAccumulators = new LinkedHashMap<>();
+ for (WorkflowRow row : workflowRows) {
+ WorkflowAccumulator workflow = workflowAccumulators.computeIfAbsent(row.workflowId(),
+ ignored -> new WorkflowAccumulator(row.workflowId(), row.workflowName(), row.criticality()));
+ workflow.quickManaged |= row.quickManaged();
+ if (row.stepId() == null) continue;
+ RequirementAccumulator requirement = workflow.requirements.computeIfAbsent(row.stepId(),
+ ignored -> new RequirementAccumulator(row));
+ if (row.roleId() != null) requirement.roleIds.add(row.roleId());
+ }
+ List workflows = workflowAccumulators.values().stream()
+ .map(WorkflowAccumulator::toItem)
+ .toList();
+
+ return new DraftCatalogResource(workspaceId, teams, members, roles, workflows);
+ }
+
+ public UUID insertTeam(UUID workspaceId, TeamRequest request) {
+ UUID id = UUID.randomUUID();
+ jdbcClient.sql("""
+ INSERT INTO teams (id, organization_id, name, department)
+ VALUES (:id, :workspaceId, :name, :department)
+ """).param("id", id).param("workspaceId", workspaceId)
+ .param("name", request.name().trim()).param("department", request.department().trim()).update();
+ return id;
+ }
+
+ public boolean teamExists(UUID workspaceId, UUID teamId) {
+ return exists("teams", workspaceId, teamId);
+ }
+
+ public void updateTeam(UUID workspaceId, UUID teamId, TeamRequest request) {
+ jdbcClient.sql("""
+ UPDATE teams SET name = :name, department = :department
+ WHERE organization_id = :workspaceId AND id = :teamId
+ """).param("name", request.name().trim()).param("department", request.department().trim())
+ .param("workspaceId", workspaceId).param("teamId", teamId).update();
+ }
+
+ public int countTeamMembers(UUID workspaceId, UUID teamId) {
+ return jdbcClient.sql("""
+ SELECT COUNT(*) FROM employees WHERE organization_id = :workspaceId AND team_id = :teamId
+ """).param("workspaceId", workspaceId).param("teamId", teamId).query(Integer.class).single();
+ }
+
+ public void deleteTeam(UUID workspaceId, UUID teamId) {
+ jdbcClient.sql("DELETE FROM teams WHERE organization_id = :workspaceId AND id = :teamId")
+ .param("workspaceId", workspaceId).param("teamId", teamId).update();
+ }
+
+ public UUID insertMember(UUID workspaceId, MemberRequest request) {
+ UUID id = UUID.randomUUID();
+ jdbcClient.sql("""
+ INSERT INTO employees (
+ id, organization_id, team_id, employee_no, name, email, status, region, shift
+ ) VALUES (
+ :id, :workspaceId, :teamId, :employeeNumber, :name, :email, :status, :region, :shift
+ )
+ """).param("id", id).param("workspaceId", workspaceId).param("teamId", request.teamId())
+ .param("employeeNumber", nullableEmployeeNumber(request.employeeNumber()))
+ .param("name", request.name().trim())
+ .param("email", nullableEmail(request.email())).param("status", request.status().name())
+ .param("region", request.region().name()).param("shift", request.shift().name()).update();
+ return id;
+ }
+
+ public boolean memberExists(UUID workspaceId, UUID memberId) {
+ return exists("employees", workspaceId, memberId);
+ }
+
+ public void updateMember(UUID workspaceId, UUID memberId, MemberRequest request) {
+ jdbcClient.sql("""
+ UPDATE employees
+ SET team_id = :teamId, employee_no = :employeeNumber, name = :name,
+ email = :email, status = :status, region = :region, shift = :shift
+ WHERE organization_id = :workspaceId AND id = :memberId
+ """).param("teamId", request.teamId())
+ .param("employeeNumber", nullableEmployeeNumber(request.employeeNumber()))
+ .param("name", request.name().trim()).param("email", nullableEmail(request.email()))
+ .param("status", request.status().name()).param("region", request.region().name())
+ .param("shift", request.shift().name()).param("workspaceId", workspaceId)
+ .param("memberId", memberId).update();
+ }
+
+ public void deleteMember(UUID workspaceId, UUID memberId) {
+ jdbcClient.sql("UPDATE teams SET manager_employee_id = NULL WHERE organization_id = :workspaceId AND manager_employee_id = :memberId")
+ .param("workspaceId", workspaceId).param("memberId", memberId).update();
+ jdbcClient.sql("UPDATE roles SET owner_employee_id = NULL WHERE organization_id = :workspaceId AND owner_employee_id = :memberId")
+ .param("workspaceId", workspaceId).param("memberId", memberId).update();
+ jdbcClient.sql("UPDATE applications SET owner_employee_id = NULL WHERE organization_id = :workspaceId AND owner_employee_id = :memberId")
+ .param("workspaceId", workspaceId).param("memberId", memberId).update();
+ jdbcClient.sql("UPDATE workflows SET owner_employee_id = NULL WHERE organization_id = :workspaceId AND owner_employee_id = :memberId")
+ .param("workspaceId", workspaceId).param("memberId", memberId).update();
+ jdbcClient.sql("DELETE FROM employee_roles WHERE employee_id = :memberId")
+ .param("memberId", memberId).update();
+ jdbcClient.sql("DELETE FROM employees WHERE organization_id = :workspaceId AND id = :memberId")
+ .param("workspaceId", workspaceId).param("memberId", memberId).update();
+ }
+
+ public UUID insertRole(UUID workspaceId, RoleRequest request) {
+ UUID id = UUID.randomUUID();
+ jdbcClient.sql("""
+ INSERT INTO roles (id, organization_id, name, description, sensitivity, owner_employee_id)
+ VALUES (:id, :workspaceId, :name, :description, :sensitivity, :ownerMemberId)
+ """).param("id", id).param("workspaceId", workspaceId).param("name", request.name().trim())
+ .param("description", request.description().trim()).param("sensitivity", request.sensitivity().name())
+ .param("ownerMemberId", request.ownerMemberId()).update();
+ return id;
+ }
+
+ public boolean roleExists(UUID workspaceId, UUID roleId) {
+ return exists("roles", workspaceId, roleId);
+ }
+
+ public void updateRole(UUID workspaceId, UUID roleId, RoleRequest request) {
+ jdbcClient.sql("""
+ UPDATE roles
+ SET name = :name, description = :description, sensitivity = :sensitivity,
+ owner_employee_id = :ownerMemberId
+ WHERE organization_id = :workspaceId AND id = :roleId
+ """).param("name", request.name().trim()).param("description", request.description().trim())
+ .param("sensitivity", request.sensitivity().name()).param("ownerMemberId", request.ownerMemberId())
+ .param("workspaceId", workspaceId).param("roleId", roleId).update();
+ }
+
+ public void deleteRole(UUID workspaceId, UUID roleId) {
+ jdbcClient.sql("DELETE FROM employee_roles WHERE role_id = :roleId").param("roleId", roleId).update();
+ jdbcClient.sql("DELETE FROM role_permissions WHERE role_id = :roleId").param("roleId", roleId).update();
+ jdbcClient.sql("DELETE FROM roles WHERE organization_id = :workspaceId AND id = :roleId")
+ .param("workspaceId", workspaceId).param("roleId", roleId).update();
+ }
+
+ public int countWorkflowsForRole(UUID workspaceId, UUID roleId) {
+ return jdbcClient.sql("""
+ SELECT COUNT(DISTINCT w.id)
+ FROM workflows w
+ JOIN workflow_steps ws ON ws.workflow_id = w.id
+ JOIN capability_permissions cp ON cp.capability_id = ws.required_capability_id
+ JOIN role_permissions rp ON rp.permission_id = cp.permission_id
+ WHERE w.organization_id = :workspaceId AND rp.role_id = :roleId
+ """).param("workspaceId", workspaceId).param("roleId", roleId)
+ .query(Integer.class).single();
+ }
+
+ public int countMatchingRoles(UUID workspaceId, Set roleIds) {
+ if (roleIds.isEmpty()) return 0;
+ return jdbcClient.sql("SELECT COUNT(*) FROM roles WHERE organization_id = :workspaceId AND id IN (:roleIds)")
+ .param("workspaceId", workspaceId).param("roleIds", roleIds).query(Integer.class).single();
+ }
+
+ public void replaceAssignments(UUID memberId, Set roleIds) {
+ jdbcClient.sql("DELETE FROM employee_roles WHERE employee_id = :memberId").param("memberId", memberId).update();
+ for (UUID roleId : roleIds) {
+ jdbcClient.sql("""
+ INSERT INTO employee_roles (employee_id, role_id, assigned_at, assigned_by)
+ VALUES (:memberId, :roleId, CURRENT_TIMESTAMP, 'workspace editor')
+ """).param("memberId", memberId).param("roleId", roleId).update();
+ }
+ }
+
+ public boolean assignmentExists(UUID workspaceId, UUID memberId, UUID roleId) {
+ return jdbcClient.sql("""
+ SELECT EXISTS (
+ SELECT 1 FROM employee_roles er
+ JOIN employees e ON e.id = er.employee_id
+ JOIN roles r ON r.id = er.role_id
+ WHERE e.organization_id = :workspaceId
+ AND r.organization_id = :workspaceId
+ AND er.employee_id = :memberId
+ AND er.role_id = :roleId
+ )
+ """).param("workspaceId", workspaceId).param("memberId", memberId).param("roleId", roleId)
+ .query(Boolean.class).single();
+ }
+
+ public UUID insertQuickWorkflow(UUID workspaceId, QuickWorkflowRequest request) {
+ UUID workflowId = UUID.randomUUID();
+ String name = request.name().trim();
+ jdbcClient.sql("INSERT INTO workflows (id, organization_id, name, criticality) VALUES (:id, :workspaceId, :name, :criticality)")
+ .param("id", workflowId).param("workspaceId", workspaceId).param("name", name)
+ .param("criticality", request.criticality().name()).update();
+ insertWorkflowRequirement(workspaceId, workflowId, new WorkflowRequirementRequest(
+ request.requirementName(), request.roleId(), request.minimumActors(), request.resilienceTarget()));
+ return workflowId;
+ }
+
+ public UUID insertWorkflowRequirement(
+ UUID workspaceId,
+ UUID workflowId,
+ WorkflowRequirementRequest request) {
+ UUID applicationId = UUID.randomUUID();
+ UUID resourceId = UUID.randomUUID();
+ UUID permissionId = UUID.randomUUID();
+ UUID capabilityId = UUID.randomUUID();
+ UUID stepId = UUID.randomUUID();
+ String workflowName = jdbcClient.sql("SELECT name FROM workflows WHERE organization_id = :workspaceId AND id = :workflowId")
+ .param("workspaceId", workspaceId).param("workflowId", workflowId).query(String.class).single();
+ String workflowCriticality = jdbcClient.sql("SELECT criticality FROM workflows WHERE organization_id = :workspaceId AND id = :workflowId")
+ .param("workspaceId", workspaceId).param("workflowId", workflowId).query(String.class).single();
+ String requirementName = request.name().trim();
+ int position = jdbcClient.sql("SELECT COALESCE(MAX(position), 0) + 1 FROM workflow_steps WHERE workflow_id = :workflowId")
+ .param("workflowId", workflowId).query(Integer.class).single();
+ String action = limited(slugAction(workflowName) + "." + slugAction(requirementName) + ".execute", 120);
+ String stepKey = (slugAction(requirementName).replace('.', '_') + "_" + position);
+ if (stepKey.length() > 80) stepKey = stepKey.substring(0, 80);
+
+ jdbcClient.sql("INSERT INTO applications (id, organization_id, name, category) VALUES (:id, :workspaceId, :name, 'Business Workflow')")
+ .param("id", applicationId).param("workspaceId", workspaceId)
+ .param("name", limited(workflowName + " · " + requirementName + " [" + position + "]", 160)).update();
+ jdbcClient.sql("INSERT INTO resources (id, application_id, name, resource_type) VALUES (:id, :applicationId, :name, 'WORKFLOW')")
+ .param("id", resourceId).param("applicationId", applicationId).param("name", requirementName).update();
+ jdbcClient.sql("""
+ INSERT INTO permissions (id, organization_id, application_id, resource_id, action, sensitivity)
+ VALUES (:id, :workspaceId, :applicationId, :resourceId, :action, :sensitivity)
+ """).param("id", permissionId).param("workspaceId", workspaceId).param("applicationId", applicationId)
+ .param("resourceId", resourceId).param("action", action).param("sensitivity", workflowCriticality).update();
+ jdbcClient.sql("INSERT INTO role_permissions (role_id, permission_id) VALUES (:roleId, :permissionId)")
+ .param("roleId", request.roleId()).param("permissionId", permissionId).update();
+ jdbcClient.sql("INSERT INTO capabilities (id, organization_id, name, description) VALUES (:id, :workspaceId, :name, :description)")
+ .param("id", capabilityId).param("workspaceId", workspaceId)
+ .param("name", limited(workflowName + ": " + requirementName, 160))
+ .param("description", "Capability generated by the quick workflow builder").update();
+ jdbcClient.sql("INSERT INTO capability_permissions (capability_id, permission_id) VALUES (:capabilityId, :permissionId)")
+ .param("capabilityId", capabilityId).param("permissionId", permissionId).update();
+ jdbcClient.sql("""
+ INSERT INTO workflow_steps (
+ id, workflow_id, step_key, name, position, required_capability_id,
+ minimum_actors, resilience_target, required_application_id
+ ) VALUES (
+ :id, :workflowId, :stepKey, :name, :position, :capabilityId,
+ :minimumActors, :resilienceTarget, :applicationId
+ )
+ """).param("id", stepId).param("workflowId", workflowId).param("stepKey", stepKey)
+ .param("name", requirementName).param("position", position)
+ .param("capabilityId", capabilityId).param("minimumActors", request.minimumActors())
+ .param("resilienceTarget", request.resilienceTarget())
+ .param("applicationId", applicationId).update();
+ return stepId;
+ }
+
+ public void deleteWorkflow(UUID workspaceId, UUID workflowId) {
+ List generatedBundles = jdbcClient.sql("""
+ SELECT DISTINCT ws.required_capability_id AS capability_id,
+ p.id AS permission_id, p.application_id
+ FROM workflow_steps ws
+ JOIN applications a ON a.id = ws.required_application_id AND a.category = 'Business Workflow'
+ JOIN capability_permissions cp ON cp.capability_id = ws.required_capability_id
+ JOIN permissions p ON p.id = cp.permission_id AND p.application_id = a.id
+ WHERE ws.workflow_id = :workflowId
+ """).param("workflowId", workflowId)
+ .query((rs, row) -> new GeneratedBundle(
+ rs.getObject("capability_id", UUID.class),
+ rs.getObject("permission_id", UUID.class),
+ rs.getObject("application_id", UUID.class)))
+ .list();
+ jdbcClient.sql("""
+ DELETE FROM workflow_step_constraints
+ WHERE workflow_step_id IN (SELECT id FROM workflow_steps WHERE workflow_id = :workflowId)
+ """).param("workflowId", workflowId).update();
+ jdbcClient.sql("DELETE FROM workflow_steps WHERE workflow_id = :workflowId")
+ .param("workflowId", workflowId).update();
+ jdbcClient.sql("DELETE FROM workflow_constraints WHERE workflow_id = :workflowId")
+ .param("workflowId", workflowId).update();
+ jdbcClient.sql("DELETE FROM workflows WHERE organization_id = :workspaceId AND id = :workflowId")
+ .param("workspaceId", workspaceId).param("workflowId", workflowId).update();
+ for (GeneratedBundle bundle : generatedBundles) {
+ jdbcClient.sql("DELETE FROM capability_permissions WHERE capability_id = :capabilityId")
+ .param("capabilityId", bundle.capabilityId()).update();
+ jdbcClient.sql("DELETE FROM capabilities WHERE organization_id = :workspaceId AND id = :capabilityId")
+ .param("workspaceId", workspaceId).param("capabilityId", bundle.capabilityId()).update();
+ jdbcClient.sql("DELETE FROM role_permissions WHERE permission_id = :permissionId")
+ .param("permissionId", bundle.permissionId()).update();
+ jdbcClient.sql("DELETE FROM permissions WHERE organization_id = :workspaceId AND id = :permissionId")
+ .param("workspaceId", workspaceId).param("permissionId", bundle.permissionId()).update();
+ }
+ generatedBundles.stream().map(GeneratedBundle::applicationId).distinct().forEach(applicationId -> {
+ jdbcClient.sql("DELETE FROM resources WHERE application_id = :applicationId")
+ .param("applicationId", applicationId).update();
+ jdbcClient.sql("DELETE FROM applications WHERE organization_id = :workspaceId AND id = :applicationId")
+ .param("workspaceId", workspaceId).param("applicationId", applicationId).update();
+ });
+ }
+
+ public boolean workflowExists(UUID workspaceId, UUID workflowId) {
+ return exists("workflows", workspaceId, workflowId);
+ }
+
+ public boolean quickWorkflowExists(UUID workspaceId, UUID workflowId) {
+ return jdbcClient.sql("""
+ SELECT EXISTS (
+ SELECT 1 FROM workflows w
+ JOIN workflow_steps ws ON ws.workflow_id = w.id
+ JOIN applications a ON a.id = ws.required_application_id
+ WHERE w.organization_id = :workspaceId AND w.id = :workflowId
+ AND a.category = 'Business Workflow'
+ )
+ """).param("workspaceId", workspaceId).param("workflowId", workflowId)
+ .query(Boolean.class).single();
+ }
+
+ public void touchWorkspace(UUID workspaceId) {
+ jdbcClient.sql("UPDATE organizations SET updated_at = CURRENT_TIMESTAMP WHERE id = :workspaceId")
+ .param("workspaceId", workspaceId).update();
+ }
+
+ private boolean exists(String table, UUID workspaceId, UUID entityId) {
+ String sql = "SELECT EXISTS (SELECT 1 FROM " + table + " WHERE organization_id = :workspaceId AND id = :entityId)";
+ return jdbcClient.sql(sql).param("workspaceId", workspaceId).param("entityId", entityId)
+ .query(Boolean.class).single();
+ }
+
+ private String nullableEmployeeNumber(String employeeNumber) {
+ return employeeNumber == null || employeeNumber.isBlank() ? null : employeeNumber.trim();
+ }
+
+ private String nullableEmail(String email) {
+ return email == null || email.isBlank() ? null : email.trim().toLowerCase();
+ }
+
+ private String slugAction(String value) {
+ return value.toLowerCase().replaceAll("[^a-z0-9]+", ".").replaceAll("(^\\.|\\.$)", "");
+ }
+
+ private String limited(String value, int maxLength) {
+ return value.length() <= maxLength ? value : value.substring(0, maxLength);
+ }
+
+ private record Assignment(UUID memberId, UUID roleId) {
+ }
+
+ private record GeneratedBundle(UUID capabilityId, UUID permissionId, UUID applicationId) {
+ }
+
+ private record WorkflowRow(
+ UUID workflowId, String workflowName, String criticality,
+ UUID stepId, String stepName, int position, int minimumActors, int resilienceTarget,
+ String requiredDepartment, String requiredRegion, String requiredShift,
+ UUID roleId, boolean quickManaged) {
+ }
+
+ private static final class WorkflowAccumulator {
+ private final UUID id;
+ private final String name;
+ private final String criticality;
+ private final Map requirements = new LinkedHashMap<>();
+ private boolean quickManaged;
+
+ private WorkflowAccumulator(UUID id, String name, String criticality) {
+ this.id = id;
+ this.name = name;
+ this.criticality = criticality;
+ }
+
+ private WorkflowItem toItem() {
+ return new WorkflowItem(id, name, criticality,
+ requirements.values().stream().map(RequirementAccumulator::toItem).toList(),
+ quickManaged);
+ }
+ }
+
+ private static final class RequirementAccumulator {
+ private final WorkflowRow row;
+ private final Set roleIds = new LinkedHashSet<>();
+
+ private RequirementAccumulator(WorkflowRow row) {
+ this.row = row;
+ }
+
+ private WorkflowRequirementItem toItem() {
+ return new WorkflowRequirementItem(row.stepId(), row.stepName(), row.position(),
+ row.minimumActors(), row.resilienceTarget(), row.requiredDepartment(),
+ row.requiredRegion(), row.requiredShift(), roleIds);
+ }
+ }
+}
diff --git a/backend/src/main/java/com/roleimpact/workspace/preview/api/DraftImpactPreviewController.java b/backend/src/main/java/com/roleimpact/workspace/preview/api/DraftImpactPreviewController.java
new file mode 100644
index 0000000..c80cb6a
--- /dev/null
+++ b/backend/src/main/java/com/roleimpact/workspace/preview/api/DraftImpactPreviewController.java
@@ -0,0 +1,32 @@
+package com.roleimpact.workspace.preview.api;
+
+import java.util.UUID;
+
+import com.roleimpact.impactengine.ImpactResult;
+import com.roleimpact.workspace.preview.application.DraftImpactPreviewService;
+
+import jakarta.validation.Valid;
+
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/api/v1/workspaces/{workspaceId}/impact-previews")
+public class DraftImpactPreviewController {
+
+ private final DraftImpactPreviewService service;
+
+ public DraftImpactPreviewController(DraftImpactPreviewService service) {
+ this.service = service;
+ }
+
+ @PostMapping
+ public ImpactResult create(
+ @PathVariable UUID workspaceId,
+ @Valid @RequestBody DraftImpactPreviewRequest request) {
+ return service.preview(workspaceId, request);
+ }
+}
diff --git a/backend/src/main/java/com/roleimpact/workspace/preview/api/DraftImpactPreviewRequest.java b/backend/src/main/java/com/roleimpact/workspace/preview/api/DraftImpactPreviewRequest.java
new file mode 100644
index 0000000..682b40a
--- /dev/null
+++ b/backend/src/main/java/com/roleimpact/workspace/preview/api/DraftImpactPreviewRequest.java
@@ -0,0 +1,10 @@
+package com.roleimpact.workspace.preview.api;
+
+import java.util.UUID;
+
+import jakarta.validation.constraints.NotNull;
+
+public record DraftImpactPreviewRequest(
+ @NotNull UUID memberId,
+ @NotNull UUID roleId) {
+}
diff --git a/backend/src/main/java/com/roleimpact/workspace/preview/application/DraftImpactPreviewService.java b/backend/src/main/java/com/roleimpact/workspace/preview/application/DraftImpactPreviewService.java
new file mode 100644
index 0000000..bfdf1ff
--- /dev/null
+++ b/backend/src/main/java/com/roleimpact/workspace/preview/application/DraftImpactPreviewService.java
@@ -0,0 +1,45 @@
+package com.roleimpact.workspace.preview.application;
+
+import java.util.UUID;
+
+import com.roleimpact.catalog.snapshot.OrganizationSnapshotAssembler;
+import com.roleimpact.impactengine.ImpactEngine;
+import com.roleimpact.impactengine.ImpactResult;
+import com.roleimpact.impactengine.InvalidImpactChangeException;
+import com.roleimpact.impactengine.RevokeEmployeeRole;
+import com.roleimpact.workspace.application.WorkspaceNotFoundException;
+import com.roleimpact.workspace.editor.application.PublishedWorkspaceMutationException;
+import com.roleimpact.workspace.editor.persistence.DraftCatalogRepository;
+import com.roleimpact.workspace.preview.api.DraftImpactPreviewRequest;
+
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+public class DraftImpactPreviewService {
+
+ private final DraftCatalogRepository catalogRepository;
+ private final OrganizationSnapshotAssembler snapshotAssembler;
+ private final ImpactEngine impactEngine;
+
+ public DraftImpactPreviewService(
+ DraftCatalogRepository catalogRepository,
+ OrganizationSnapshotAssembler snapshotAssembler,
+ ImpactEngine impactEngine) {
+ this.catalogRepository = catalogRepository;
+ this.snapshotAssembler = snapshotAssembler;
+ this.impactEngine = impactEngine;
+ }
+
+ @Transactional(readOnly = true)
+ public ImpactResult preview(UUID workspaceId, DraftImpactPreviewRequest request) {
+ String status = catalogRepository.findWorkspaceStatus(workspaceId)
+ .orElseThrow(() -> new WorkspaceNotFoundException(workspaceId));
+ if (!"DRAFT".equals(status)) throw new PublishedWorkspaceMutationException();
+ if (!catalogRepository.assignmentExists(workspaceId, request.memberId(), request.roleId())) {
+ throw new InvalidImpactChangeException("The selected member does not currently hold this role");
+ }
+ var snapshot = snapshotAssembler.assemble(workspaceId);
+ return impactEngine.analyze(snapshot, new RevokeEmployeeRole(request.memberId(), request.roleId()));
+ }
+}
diff --git a/backend/src/main/resources/db/migration/V5__make_member_email_optional.sql b/backend/src/main/resources/db/migration/V5__make_member_email_optional.sql
new file mode 100644
index 0000000..0d4762e
--- /dev/null
+++ b/backend/src/main/resources/db/migration/V5__make_member_email_optional.sql
@@ -0,0 +1,2 @@
+ALTER TABLE employees
+ ALTER COLUMN email DROP NOT NULL;
diff --git a/backend/src/main/resources/db/migration/V6__make_employee_number_optional.sql b/backend/src/main/resources/db/migration/V6__make_employee_number_optional.sql
new file mode 100644
index 0000000..9a2c0b0
--- /dev/null
+++ b/backend/src/main/resources/db/migration/V6__make_employee_number_optional.sql
@@ -0,0 +1,2 @@
+ALTER TABLE employees
+ ALTER COLUMN employee_no DROP NOT NULL;
diff --git a/backend/src/test/java/com/roleimpact/catalog/persistence/CatalogMigrationIntegrationTest.java b/backend/src/test/java/com/roleimpact/catalog/persistence/CatalogMigrationIntegrationTest.java
index 99b9fc7..213659d 100644
--- a/backend/src/test/java/com/roleimpact/catalog/persistence/CatalogMigrationIntegrationTest.java
+++ b/backend/src/test/java/com/roleimpact/catalog/persistence/CatalogMigrationIntegrationTest.java
@@ -95,7 +95,13 @@ SELECT COUNT(*)
.query(Integer.class)
.single();
- assertThat(successfulMigrations).isEqualTo(4);
+ assertThat(successfulMigrations).isEqualTo(6);
+ var employeeNumberNullable = jdbcClient.sql("""
+ SELECT is_nullable
+ FROM information_schema.columns
+ WHERE table_schema = 'public' AND table_name = 'employees' AND column_name = 'employee_no'
+ """).query(String.class).single();
+ assertThat(employeeNumberNullable).isEqualTo("YES");
}
@Test
diff --git a/backend/src/test/java/com/roleimpact/workspace/WorkspaceIntegrationTest.java b/backend/src/test/java/com/roleimpact/workspace/WorkspaceIntegrationTest.java
index ccce39f..6f69d60 100644
--- a/backend/src/test/java/com/roleimpact/workspace/WorkspaceIntegrationTest.java
+++ b/backend/src/test/java/com/roleimpact/workspace/WorkspaceIntegrationTest.java
@@ -3,6 +3,8 @@
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.put;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.header;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
@@ -97,6 +99,29 @@ void createsBlankAndClonedDraftsWithoutChangingThePublishedTemplate() throws Exc
assertThat(countSharedEmployeeIds(HARBORLINE_ID, cloneId)).isZero();
assertThat(countNamedEmployees(cloneId, "Priya Sharma")).isOne();
+ var clonedCatalog = mockMvc.perform(get("/api/v1/workspaces/{workspaceId}/catalog", cloneId))
+ .andExpect(status().isOk())
+ .andExpect(jsonPath("$.workflows[?(@.name == 'Vendor Payment')].requirements[?(@.name == 'High-Value Payment Approval')]").exists())
+ .andReturn();
+ var catalogJson = objectMapper.readTree(clonedCatalog.getResponse().getContentAsString());
+ UUID priyaId = findId(catalogJson, "members", "Priya Sharma");
+ UUID aishaId = findId(catalogJson, "members", "Aisha Khan");
+ UUID sofiaId = findId(catalogJson, "members", "Sofia Martinez");
+ UUID financeApproverId = findId(catalogJson, "roles", "Finance Approver");
+ UUID seniorSupportId = findId(catalogJson, "roles", "Senior Support");
+ UUID supportAgentId = findId(catalogJson, "roles", "Support Agent");
+ assertPreview(cloneId, priyaId, financeApproverId, "CRITICAL", 1, 1);
+ assertPreview(cloneId, aishaId, seniorSupportId, "MEDIUM", 0, 1);
+ assertPreview(cloneId, sofiaId, supportAgentId, "LOW", 0, 0);
+
+ UUID clonedWorkflowId = UUID.fromString(catalogJson
+ .path("workflows").get(0).path("id").asText());
+ mockMvc.perform(delete("/api/v1/workspaces/{workspaceId}/catalog/workflows/{workflowId}", cloneId, clonedWorkflowId))
+ .andExpect(status().isOk())
+ .andExpect(jsonPath("$.workflows.length()").value(3));
+ assertThat(countForOrganization("workflows", cloneId)).isEqualTo(3);
+ assertThat(countForOrganization("workflows", HARBORLINE_ID)).isEqualTo(4);
+
mockMvc.perform(post("/api/v1/workspaces")
.contentType(MediaType.APPLICATION_JSON)
.content(workspaceRequest("Duplicate", "harborline-sandbox")))
@@ -110,6 +135,172 @@ void createsBlankAndClonedDraftsWithoutChangingThePublishedTemplate() throws Exc
.andExpect(jsonPath("$.code").value("INVALID_WORKSPACE"));
}
+ @Test
+ void buildsTeamsMembersAndRolesInsideADraftOnly() throws Exception {
+ var workspaceResponse = mockMvc.perform(post("/api/v1/workspaces")
+ .contentType(MediaType.APPLICATION_JSON)
+ .content(workspaceRequest("Atlas Editor Test", "atlas-editor-test")))
+ .andExpect(status().isCreated())
+ .andReturn();
+ UUID workspaceId = responseId(workspaceResponse.getResponse().getContentAsString());
+
+ var teamResponse = mockMvc.perform(post("/api/v1/workspaces/{workspaceId}/catalog/teams", workspaceId)
+ .contentType(MediaType.APPLICATION_JSON)
+ .content("""
+ {"name":"Platform","department":"Engineering"}
+ """))
+ .andExpect(status().isOk())
+ .andExpect(jsonPath("$.teams[0].name").value("Platform"))
+ .andExpect(jsonPath("$.teams[0].memberCount").value(0))
+ .andReturn();
+ UUID teamId = UUID.fromString(objectMapper.readTree(teamResponse.getResponse().getContentAsString())
+ .path("teams").get(0).path("id").asText());
+
+ var memberResponse = mockMvc.perform(post("/api/v1/workspaces/{workspaceId}/catalog/members", workspaceId)
+ .contentType(MediaType.APPLICATION_JSON)
+ .content("""
+ {
+ "teamId":"%s", "name":"Maya Singh", "status":"ACTIVE",
+ "region":"NORTH_AMERICA", "shift":"DAY"
+ }
+ """.formatted(teamId)))
+ .andExpect(status().isOk())
+ .andExpect(jsonPath("$.members[0].name").value("Maya Singh"))
+ .andExpect(jsonPath("$.members[0].employeeNumber").doesNotExist())
+ .andExpect(jsonPath("$.members[0].email").doesNotExist())
+ .andExpect(jsonPath("$.teams[0].memberCount").value(1))
+ .andReturn();
+ UUID memberId = UUID.fromString(objectMapper.readTree(memberResponse.getResponse().getContentAsString())
+ .path("members").get(0).path("id").asText());
+
+ var roleResponse = mockMvc.perform(post("/api/v1/workspaces/{workspaceId}/catalog/roles", workspaceId)
+ .contentType(MediaType.APPLICATION_JSON)
+ .content("""
+ {
+ "name":"Release Manager", "description":"Approves production releases",
+ "sensitivity":"HIGH", "ownerMemberId":"%s"
+ }
+ """.formatted(memberId)))
+ .andExpect(status().isOk())
+ .andExpect(jsonPath("$.roles[0].name").value("Release Manager"))
+ .andReturn();
+ UUID roleId = UUID.fromString(objectMapper.readTree(roleResponse.getResponse().getContentAsString())
+ .path("roles").get(0).path("id").asText());
+
+ mockMvc.perform(put("/api/v1/workspaces/{workspaceId}/catalog/members/{memberId}/roles", workspaceId, memberId)
+ .contentType(MediaType.APPLICATION_JSON)
+ .content("{\"roleIds\":[\"" + roleId + "\"]}"))
+ .andExpect(status().isOk())
+ .andExpect(jsonPath("$.members[0].roleIds[0]").value(roleId.toString()))
+ .andExpect(jsonPath("$.roles[0].memberCount").value(1));
+
+ mockMvc.perform(put("/api/v1/workspaces/{workspaceId}/catalog/teams/{teamId}", workspaceId, teamId)
+ .contentType(MediaType.APPLICATION_JSON)
+ .content("{\"name\":\"Platform Operations\",\"department\":\"Technology\"}"))
+ .andExpect(status().isOk())
+ .andExpect(jsonPath("$.teams[0].name").value("Platform Operations"));
+ mockMvc.perform(put("/api/v1/workspaces/{workspaceId}/catalog/members/{memberId}", workspaceId, memberId)
+ .contentType(MediaType.APPLICATION_JSON)
+ .content("""
+ {
+ "teamId":"%s", "employeeNumber":"AT-001", "name":"Maya Patel",
+ "email":"maya@atlas.test", "status":"ACTIVE",
+ "region":"NORTH_AMERICA", "shift":"DAY"
+ }
+ """.formatted(teamId)))
+ .andExpect(status().isOk())
+ .andExpect(jsonPath("$.members[0].name").value("Maya Patel"));
+ mockMvc.perform(put("/api/v1/workspaces/{workspaceId}/catalog/roles/{roleId}", workspaceId, roleId)
+ .contentType(MediaType.APPLICATION_JSON)
+ .content("""
+ {
+ "name":"Production Release Manager", "description":"Approves production releases",
+ "sensitivity":"CRITICAL", "ownerMemberId":"%s"
+ }
+ """.formatted(memberId)))
+ .andExpect(status().isOk())
+ .andExpect(jsonPath("$.roles[0].name").value("Production Release Manager"))
+ .andExpect(jsonPath("$.roles[0].sensitivity").value("CRITICAL"));
+
+ var workflowResponse = mockMvc.perform(post("/api/v1/workspaces/{workspaceId}/catalog/workflows/quick", workspaceId)
+ .contentType(MediaType.APPLICATION_JSON)
+ .content("""
+ {
+ "name":"Production Deployment", "criticality":"CRITICAL",
+ "requirementName":"Approve production release", "roleId":"%s",
+ "minimumActors":1, "resilienceTarget":1
+ }
+ """.formatted(roleId)))
+ .andExpect(status().isOk())
+ .andExpect(jsonPath("$.workflows[0].name").value("Production Deployment"))
+ .andExpect(jsonPath("$.workflows[0].requirements[0].name").value("Approve production release"))
+ .andExpect(jsonPath("$.workflows[0].requirements[0].roleIds[0]").value(roleId.toString()))
+ .andExpect(jsonPath("$.workflows[0].quickManaged").value(true))
+ .andReturn();
+ UUID workflowId = UUID.fromString(objectMapper.readTree(workflowResponse.getResponse().getContentAsString())
+ .path("workflows").get(0).path("id").asText());
+
+ assertThat(countForOrganization("applications", workspaceId)).isEqualTo(1);
+ assertThat(countForOrganization("permissions", workspaceId)).isEqualTo(1);
+ assertThat(countForOrganization("capabilities", workspaceId)).isEqualTo(1);
+ assertThat(countForOrganization("workflows", workspaceId)).isEqualTo(1);
+
+ mockMvc.perform(post("/api/v1/workspaces/{workspaceId}/catalog/workflows/{workflowId}/requirements", workspaceId, workflowId)
+ .contentType(MediaType.APPLICATION_JSON)
+ .content("""
+ {
+ "name":"Deploy release", "roleId":"%s",
+ "minimumActors":1, "resilienceTarget":2
+ }
+ """.formatted(roleId)))
+ .andExpect(status().isOk())
+ .andExpect(jsonPath("$.workflows[0].requirements.length()").value(2))
+ .andExpect(jsonPath("$.workflows[0].requirements[1].resilienceTarget").value(2));
+ assertThat(countForOrganization("applications", workspaceId)).isEqualTo(2);
+ assertThat(countForOrganization("permissions", workspaceId)).isEqualTo(2);
+ assertThat(countForOrganization("capabilities", workspaceId)).isEqualTo(2);
+
+ mockMvc.perform(post("/api/v1/workspaces/{workspaceId}/impact-previews", workspaceId)
+ .contentType(MediaType.APPLICATION_JSON)
+ .content("""
+ {"memberId":"%s","roleId":"%s"}
+ """.formatted(memberId, roleId)))
+ .andExpect(status().isOk())
+ .andExpect(jsonPath("$.baselineVersion").value(0))
+ .andExpect(jsonPath("$.overallSeverity").value("CRITICAL"))
+ .andExpect(jsonPath("$.executiveSummary.workflowsBlocked").value(1))
+ .andExpect(jsonPath("$.changeSet.employee.name").value("Maya Patel"))
+ .andExpect(jsonPath("$.changeSet.role.name").value("Production Release Manager"))
+ .andExpect(jsonPath("$.workflowImpacts[0].workflowName").value("Production Deployment"))
+ .andExpect(jsonPath("$.workflowImpacts[0].scenarioStatus").value("BLOCKED"));
+
+ mockMvc.perform(delete("/api/v1/workspaces/{workspaceId}/catalog/teams/{teamId}", workspaceId, teamId))
+ .andExpect(status().isConflict())
+ .andExpect(jsonPath("$.code").value("DRAFT_CATALOG_CONFLICT"));
+
+ mockMvc.perform(post("/api/v1/workspaces/{workspaceId}/catalog/teams", HARBORLINE_ID)
+ .contentType(MediaType.APPLICATION_JSON)
+ .content("{\"name\":\"Illegal\",\"department\":\"Test\"}"))
+ .andExpect(status().isConflict())
+ .andExpect(jsonPath("$.message").value(org.hamcrest.Matchers.containsString("immutable")));
+
+ mockMvc.perform(delete("/api/v1/workspaces/{workspaceId}/catalog/workflows/{workflowId}", workspaceId, workflowId))
+ .andExpect(status().isOk())
+ .andExpect(jsonPath("$.workflows").isEmpty());
+ assertThat(countForOrganization("applications", workspaceId)).isZero();
+ assertThat(countForOrganization("permissions", workspaceId)).isZero();
+ assertThat(countForOrganization("capabilities", workspaceId)).isZero();
+
+ mockMvc.perform(delete("/api/v1/workspaces/{workspaceId}/catalog/roles/{roleId}", workspaceId, roleId))
+ .andExpect(status().isOk())
+ .andExpect(jsonPath("$.members[0].roleIds").isEmpty());
+ mockMvc.perform(delete("/api/v1/workspaces/{workspaceId}/catalog/members/{memberId}", workspaceId, memberId))
+ .andExpect(status().isOk());
+ mockMvc.perform(delete("/api/v1/workspaces/{workspaceId}/catalog/teams/{teamId}", workspaceId, teamId))
+ .andExpect(status().isOk())
+ .andExpect(jsonPath("$.teams").isEmpty());
+ }
+
private String workspaceRequest(String name, String slug) throws Exception {
return objectMapper.writeValueAsString(new WorkspaceApiRequest(name, slug));
}
@@ -118,6 +309,31 @@ private UUID responseId(String response) throws Exception {
return UUID.fromString(objectMapper.readTree(response).path("id").asText());
}
+ private UUID findId(com.fasterxml.jackson.databind.JsonNode root, String collection, String name) {
+ for (var item : root.path(collection)) {
+ if (name.equals(item.path("name").asText())) return UUID.fromString(item.path("id").asText());
+ }
+ throw new IllegalArgumentException(name + " was not found in " + collection);
+ }
+
+ private void assertPreview(
+ UUID workspaceId,
+ UUID memberId,
+ UUID roleId,
+ String severity,
+ int blocked,
+ int degraded) throws Exception {
+ mockMvc.perform(post("/api/v1/workspaces/{workspaceId}/impact-previews", workspaceId)
+ .contentType(MediaType.APPLICATION_JSON)
+ .content("""
+ {"memberId":"%s","roleId":"%s"}
+ """.formatted(memberId, roleId)))
+ .andExpect(status().isOk())
+ .andExpect(jsonPath("$.overallSeverity").value(severity))
+ .andExpect(jsonPath("$.executiveSummary.workflowsBlocked").value(blocked))
+ .andExpect(jsonPath("$.executiveSummary.workflowsDegraded").value(degraded));
+ }
+
private String workspaceState(UUID id) {
return jdbcClient.sql("""
SELECT workspace_status || '|' || current_version
@@ -146,6 +362,13 @@ SELECT COUNT(*) FROM employees WHERE organization_id = :organizationId AND name
""").param("organizationId", organizationId).param("name", name).query(Integer.class).single();
}
+ private int countForOrganization(String table, UUID organizationId) {
+ var allowed = java.util.Set.of("applications", "permissions", "capabilities", "workflows");
+ if (!allowed.contains(table)) throw new IllegalArgumentException("Unexpected table: " + table);
+ return jdbcClient.sql("SELECT COUNT(*) FROM " + table + " WHERE organization_id = :organizationId")
+ .param("organizationId", organizationId).query(Integer.class).single();
+ }
+
private record WorkspaceApiRequest(String name, String slug) {
}
}
diff --git a/frontend/src/App.css b/frontend/src/App.css
index d932735..8c7ccd1 100644
--- a/frontend/src/App.css
+++ b/frontend/src/App.css
@@ -146,7 +146,7 @@
.workspace-mini-stats {
display: grid;
- grid-template-columns: repeat(3, 1fr);
+ grid-template-columns: repeat(4, 1fr);
margin-bottom: 1rem;
padding: 0.9rem 0;
border-top: 1px solid #2c3040;
@@ -257,50 +257,1451 @@
color: #a995f1;
}
-@media (max-width: 60rem) {
- .workspace-choice-grid {
- grid-template-columns: 1fr;
- }
+.draft-editor {
+ margin: 4rem 0 2rem;
+}
- .workspace-choice {
- min-height: 0;
- }
+.editor-summary {
+ grid-template-columns: repeat(4, 1fr);
+ margin: 1.5rem 0 1rem;
+}
- .workspace-choice > div > p:last-child {
- max-width: 40rem;
- }
+.editor-heading {
+ display: flex;
+ align-items: flex-end;
+ justify-content: space-between;
+ gap: 2rem;
+ margin-bottom: 1.25rem;
+}
- .workspace-choice form,
- .workspace-choice > button,
- .workspace-mini-stats {
- margin-top: 2rem;
- }
+.editor-heading h2 {
+ margin-bottom: 0;
+ font-size: clamp(2rem, 4vw, 3.2rem);
+ letter-spacing: -0.05em;
+}
- .draft-summary {
- grid-template-columns: repeat(3, 1fr);
- }
+.editor-view-switch {
+ display: flex;
+ padding: 0.25rem;
+ border: 1px solid #303546;
+ border-radius: 0.75rem;
+ background: #11141c;
}
-@media (max-width: 36rem) {
- .workspace-home-header {
- padding: 0 1rem;
- }
+.editor-view-switch button {
+ padding: 0.55rem 0.75rem;
+ border: 0;
+ background: transparent;
+ color: #858da1;
+ font-size: 0.7rem;
+}
- .workspace-home-main,
- .draft-main {
- width: min(100% - 1.25rem, 76rem);
- }
+.editor-view-switch button.active {
+ background: #2a2444;
+ color: #e6e0ff;
+}
- .draft-summary {
- grid-template-columns: repeat(2, 1fr);
- }
+.risk-callout {
+ display: grid;
+ grid-template-columns: auto minmax(0, 1fr) auto;
+ gap: 0.9rem;
+ align-items: center;
+ margin: 0 0 1rem;
+ padding: 0.9rem 1rem;
+ border: 1px solid #664653;
+ border-radius: 0.85rem;
+ background: linear-gradient(135deg, #261a22, #17151d);
+}
- .builder-next-card {
- grid-template-columns: 1fr;
- }
+.risk-callout > span {
+ display: grid;
+ width: 2rem;
+ height: 2rem;
+ place-items: center;
+ border-radius: 50%;
+ background: #6d3443;
+ color: #ffc0cc;
+ font-weight: 900;
+}
- .builder-next-card .choice-number {
- display: none;
+.risk-callout strong { color: #f4d5dc; font-size: 0.8rem; }
+.risk-callout p { margin: 0.2rem 0 0; color: #a99099; font-size: 0.7rem; }
+.risk-callout button { white-space: nowrap; }
+
+.editor-stages {
+ display: grid;
+ grid-template-columns: repeat(3, 1fr);
+ gap: 1px;
+ overflow: hidden;
+ border: 1px solid #2b3040;
+ border-radius: 0.9rem 0.9rem 0 0;
+ background: #2b3040;
+}
+
+.editor-stages button {
+ display: grid;
+ grid-template-columns: auto 1fr;
+ gap: 0.2rem 0.75rem;
+ align-items: center;
+ padding: 1rem 1.15rem;
+ border: 0;
+ border-radius: 0;
+ background: #151821;
+ color: #8e96aa;
+ text-align: left;
+}
+
+.editor-stages button > span {
+ display: grid;
+ width: 1.65rem;
+ height: 1.65rem;
+ grid-row: 1 / 3;
+ place-items: center;
+ border: 1px solid #3a3f51;
+ border-radius: 50%;
+ font-size: 0.65rem;
+}
+
+.editor-stages button strong {
+ color: #e6e7ed;
+}
+
+.editor-stages button small {
+ font-size: 0.68rem;
+}
+
+.editor-stages button.active {
+ background: linear-gradient(135deg, #211d35, #181923);
+ box-shadow: inset 0 -2px #8063ec;
+}
+
+.editor-stages button.active > span {
+ border-color: #8568ed;
+ background: #6d4de0;
+ color: white;
+}
+
+.editor-stages button:disabled {
+ cursor: not-allowed;
+ opacity: 0.45;
+}
+
+.editor-layout {
+ display: grid;
+ grid-template-columns: minmax(18rem, 0.72fr) minmax(0, 1.28fr);
+ gap: 1px;
+ min-height: 30rem;
+ overflow: hidden;
+ border: 1px solid #2b3040;
+ border-top: 0;
+ border-radius: 0 0 0.9rem 0.9rem;
+ background: #2b3040;
+}
+
+.editor-form,
+.editor-list,
+.assignment-panel {
+ background: #12151e;
+}
+
+.editor-form {
+ display: flex;
+ flex-direction: column;
+ gap: 1rem;
+ padding: clamp(1.25rem, 3vw, 2rem);
+}
+
+.editor-form h3,
+.editor-list h3,
+.assignment-panel h3 {
+ margin-bottom: 0.4rem;
+ font-size: 1.35rem;
+ letter-spacing: -0.025em;
+}
+
+.editor-form > div:first-child > p:last-child {
+ margin-bottom: 0;
+ color: #858da2;
+ font-size: 0.82rem;
+ line-height: 1.55;
+}
+
+.editor-form > button {
+ margin-top: auto;
+}
+
+.editor-field {
+ display: grid;
+ gap: 0.42rem;
+}
+
+.editor-field > span {
+ color: #abb2c3;
+ font-size: 0.72rem;
+ font-weight: 650;
+}
+
+.editor-field input,
+.editor-field select,
+.editor-field textarea {
+ width: 100%;
+ box-sizing: border-box;
+ padding: 0.75rem 0.8rem;
+ border: 1px solid #34394a;
+ border-radius: 0.6rem;
+ outline: 0;
+ background: #0c0f16;
+ color: #f0f1f5;
+ font: inherit;
+}
+
+.editor-field textarea {
+ min-height: 6rem;
+ resize: vertical;
+}
+
+.generated-hint {
+ margin: -0.25rem 0 0;
+ color: #7f879b;
+ font-size: 0.74rem;
+ line-height: 1.5;
+}
+
+.generated-hint code {
+ color: #b7a6f5;
+}
+
+.editor-field input:focus-visible,
+.editor-field select:focus-visible,
+.editor-field textarea:focus-visible {
+ border-color: #8063ec;
+ box-shadow: 0 0 0 3px rgb(109 77 224 / 16%);
+}
+
+.field-row {
+ display: grid;
+ grid-template-columns: 1fr 1fr;
+ gap: 0.75rem;
+}
+
+.shared-role-picker,
+.reuse-existing {
+ padding: 0.9rem;
+ border: 1px solid #37314f;
+ border-radius: 0.7rem;
+ background: #171525;
+}
+
+.shared-role-picker {
+ display: grid;
+ gap: 0.55rem;
+}
+
+.shared-role-picker legend {
+ padding: 0 0.35rem;
+ color: #d8d1f5;
+ font-size: 0.78rem;
+ font-weight: 700;
+}
+
+.role-picker-summary {
+ display: flex;
+ justify-content: space-between;
+ gap: 0.75rem;
+ color: #858da2;
+ font-size: 0.74rem;
+}
+
+.role-picker-summary strong { flex: 0 0 auto; color: #c8bdf6; }
+.role-member-search input { min-height: 2.4rem; }
+
+.shared-role-picker > p {
+ margin: 0;
+ color: #858da2;
+ font-size: 0.74rem;
+}
+
+.quick-role-member-list {
+ display: grid;
+ max-height: 12rem;
+ overflow-y: auto;
+ gap: 0.25rem;
+ padding-right: 0.25rem;
+}
+
+.quick-role-member-list > p {
+ margin: 0;
+ color: #858da2;
+ font-size: 0.74rem;
+}
+
+.shared-role-picker > label:not(.role-member-search),
+.quick-role-member-list > label {
+ display: inline-flex;
+ align-items: center;
+ gap: 0.4rem;
+ padding: 0.45rem 0.5rem;
+ border: 1px solid #34394a;
+ border-radius: 0.45rem;
+ color: #b7bdcd;
+ font-size: 0.74rem;
+}
+
+.quick-role-member-list > label:hover { background: #211d32; }
+
+.reuse-existing {
+ display: grid;
+ gap: 0.55rem;
+ color: #bcb1ea;
+}
+
+.reuse-existing p {
+ margin: 0;
+ color: #9299aa;
+ font-size: 0.76rem;
+ line-height: 1.5;
+}
+
+.reuse-existing .secondary-button {
+ justify-self: start;
+ margin-top: 0;
+}
+
+.editor-list {
+ padding: clamp(1.25rem, 3vw, 2rem);
+}
+
+.editor-list-heading {
+ padding-bottom: 1rem;
+ border-bottom: 1px solid #292d3a;
+}
+
+.editor-item {
+ display: flex;
+ align-items: center;
+ justify-content: space-between;
+ gap: 1rem;
+ padding: 1rem 0;
+ border-bottom: 1px solid #252936;
+}
+
+.editor-item > div {
+ display: grid;
+ gap: 0.3rem;
+}
+
+.editor-item span {
+ color: #858da1;
+ font-size: 0.74rem;
+ text-transform: capitalize;
+}
+
+.editor-item small {
+ color: #aeb5c7;
+ font-size: 0.7rem;
+ line-height: 1.45;
+}
+
+.workflow-item {
+ align-items: flex-start;
+}
+
+.workflow-item ul {
+ display: grid;
+ gap: 0.35rem;
+ margin: 0.35rem 0 0;
+ padding-left: 1rem;
+ color: #aeb5c7;
+ font-size: 0.72rem;
+ line-height: 1.45;
+}
+
+.danger-text {
+ padding: 0.3rem;
+ border: 0;
+ background: transparent;
+ color: #f39aa9;
+ font-size: 0.72rem;
+}
+
+.item-actions {
+ display: flex;
+ gap: 0.4rem;
+}
+
+.edit-text {
+ padding: 0.3rem;
+ border: 0;
+ background: transparent;
+ color: #a995f1;
+ font-size: 0.72rem;
+}
+
+.secondary-button {
+ margin-top: -0.45rem;
+ border-color: #34394a;
+ background: transparent;
+ color: #aab1c3;
+}
+
+.danger-text:disabled {
+ color: #5e6473;
+ cursor: not-allowed;
+}
+
+.editor-empty,
+.editor-state {
+ padding: 2rem 0;
+ color: #7f879b;
+}
+
+.editor-error {
+ color: #fda4af;
+}
+
+.roles-layout {
+ grid-template-columns: minmax(18rem, 0.68fr) minmax(0, 1.32fr);
+}
+
+.editor-stack {
+ display: grid;
+ gap: 1px;
+ background: #2b3040;
+}
+
+.assignment-panel {
+ padding: clamp(1.25rem, 3vw, 2rem);
+}
+
+.assignment-panel fieldset {
+ display: flex;
+ flex-wrap: wrap;
+ gap: 0.55rem;
+ margin: 1rem 0 0;
+ padding: 1rem;
+ border: 1px solid #2e3342;
+ border-radius: 0.7rem;
+}
+
+.assignment-panel legend {
+ padding: 0 0.4rem;
+ color: #dfe1e8;
+ font-size: 0.8rem;
+ font-weight: 700;
+}
+
+.assignment-panel label {
+ display: inline-flex;
+ align-items: center;
+ gap: 0.45rem;
+ padding: 0.45rem 0.65rem;
+ border: 1px solid #34394a;
+ border-radius: 999px;
+ color: #aeb5c6;
+ font-size: 0.72rem;
+}
+
+.assignment-panel input {
+ accent-color: #8063ec;
+}
+
+.canvas-builder {
+ position: relative;
+ display: grid;
+ grid-template-columns: 12.5rem minmax(32rem, 1fr) 16rem;
+ min-height: 42rem;
+ overflow: hidden;
+ border: 1px solid #2b3040;
+ border-radius: 1rem;
+ background: #2b3040;
+ box-shadow: 0 28px 80px rgb(0 0 0 / 20%);
+}
+
+.canvas-toolbox,
+.canvas-inventory,
+.organization-canvas {
+ min-width: 0;
+ background: #11141c;
+}
+
+.canvas-toolbox,
+.canvas-inventory {
+ padding: 1.15rem;
+}
+
+.canvas-toolbox {
+ display: flex;
+ flex-direction: column;
+ gap: 1.1rem;
+ border-right: 1px solid #2b3040;
+}
+
+.canvas-toolbox h3,
+.canvas-inventory h3 {
+ margin: 0 0 0.4rem;
+ font-size: 1.05rem;
+}
+
+.canvas-toolbox p:not(.section-kicker) {
+ margin: 0;
+ color: #7f879a;
+ font-size: 0.72rem;
+ line-height: 1.55;
+}
+
+.canvas-palette {
+ display: grid;
+ gap: 0.55rem;
+}
+
+.palette-object {
+ display: grid;
+ grid-template-columns: 2rem 1fr;
+ gap: 0.05rem 0.65rem;
+ align-items: center;
+ padding: 0.7rem;
+ border: 1px solid #303546;
+ background: #171a24;
+ color: #e8e9ee;
+ text-align: left;
+}
+
+.palette-object:hover {
+ border-color: #7660d5;
+ background: #211d33;
+}
+
+.palette-object > span {
+ display: grid;
+ width: 2rem;
+ height: 2rem;
+ grid-row: 1 / 3;
+ place-items: center;
+ border-radius: 0.55rem;
+ background: #2f2850;
+ color: #c8bdf6;
+ font-size: 0.72rem;
+ font-weight: 800;
+}
+
+.palette-object.member > span,
+.inventory-icon.member,
+.organization-node.member .organization-node-icon { background: #173e46; color: #80e1dc; }
+.palette-object.role > span,
+.inventory-icon.role,
+.organization-node.role .organization-node-icon { background: #4a3022; color: #f6bd79; }
+.inventory-icon.responsibility,
+.organization-node.responsibility .organization-node-icon { background: #183b2a; color: #7ee6a4; }
+.palette-object.workflow > span,
+.inventory-icon.workflow,
+.organization-node.workflow .organization-node-icon { background: #482632; color: #f5a2b8; }
+
+.palette-object strong {
+ font-size: 0.77rem;
+}
+
+.palette-object small {
+ color: #777f92;
+ font-size: 0.61rem;
+ font-weight: 500;
+}
+
+.canvas-help {
+ display: grid;
+ gap: 0.35rem;
+ margin-top: auto;
+ padding: 0.8rem;
+ border: 1px solid #302b46;
+ border-radius: 0.7rem;
+ background: #171522;
+}
+
+.canvas-help strong { color: #b6a9ec; font-size: 0.67rem; }
+.canvas-help span { color: #7e8598; font-size: 0.63rem; line-height: 1.5; }
+
+.organization-canvas {
+ position: relative;
+ display: grid;
+ grid-template-rows: auto 1fr;
+}
+
+.canvas-toolbar {
+ display: flex;
+ min-height: 3.5rem;
+ align-items: center;
+ justify-content: space-between;
+ gap: 1rem;
+ padding: 0.65rem 0.9rem;
+ border-bottom: 1px solid #2b3040;
+}
+
+.canvas-toolbar > div {
+ display: grid;
+ gap: 0.1rem;
+}
+
+.canvas-toolbar strong { font-size: 0.76rem; }
+.canvas-toolbar span { color: #747c90; font-size: 0.62rem; }
+.canvas-toolbar button { margin: 0; padding: 0.45rem 0.65rem; font-size: 0.65rem; }
+
+.canvas-toolbar-actions {
+ display: flex;
+ align-items: center;
+ gap: 0.4rem;
+}
+
+.canvas-toolbar-actions select {
+ max-width: 10rem;
+ padding: 0.48rem 0.55rem;
+ border: 1px solid #34394a;
+ border-radius: 0.55rem;
+ outline: 0;
+ background: #0c0f16;
+ color: #cfd2dc;
+ font-size: 0.65rem;
+}
+
+.canvas-dropzone {
+ position: relative;
+ min-height: 38rem;
+ background: #0d1017;
+}
+
+.canvas-dropzone .react-flow__controls {
+ overflow: hidden;
+ border: 1px solid #333849;
+ border-radius: 0.55rem;
+ box-shadow: none;
+}
+
+.canvas-dropzone .react-flow__controls-button {
+ border: 0;
+ border-bottom: 1px solid #333849;
+ border-radius: 0;
+ background: #171a24;
+ fill: #b0b6c5;
+}
+
+.canvas-empty {
+ position: absolute;
+ top: 50%;
+ left: 50%;
+ z-index: 4;
+ display: grid;
+ width: min(20rem, calc(100% - 3rem));
+ justify-items: center;
+ transform: translate(-50%, -50%);
+ color: #858da1;
+ text-align: center;
+ pointer-events: none;
+}
+
+.canvas-empty > span {
+ display: grid;
+ width: 3rem;
+ height: 3rem;
+ margin-bottom: 0.9rem;
+ place-items: center;
+ border: 1px dashed #66579f;
+ border-radius: 0.8rem;
+ color: #a793ef;
+ font-size: 1.5rem;
+}
+
+.canvas-empty strong { color: #dfe1e8; }
+.canvas-empty p { margin: 0.35rem 0 1rem; font-size: 0.75rem; }
+.canvas-empty button { pointer-events: auto; }
+
+.organization-node {
+ display: grid;
+ width: 13rem;
+ grid-template-columns: 2.4rem minmax(0, 1fr);
+ gap: 0.7rem;
+ align-items: center;
+ padding: 0.8rem;
+ border: 1px solid #3a4052;
+ border-radius: 0.8rem;
+ background: linear-gradient(145deg, #1b1f2b, #141720);
+ box-shadow: 0 12px 30px rgb(0 0 0 / 28%);
+}
+
+.organization-node.selected {
+ border-color: #9278f3;
+ box-shadow: 0 0 0 3px rgb(128 99 236 / 18%), 0 12px 30px rgb(0 0 0 / 28%);
+}
+
+.organization-node.highlighted {
+ border-color: #a78bfa;
+ box-shadow: 0 0 0 3px rgb(128 99 236 / 16%), 0 12px 30px rgb(0 0 0 / 28%);
+}
+
+.organization-node.dimmed { opacity: 0.24; }
+.organization-node.responsibility { border-color: #285c43; }
+
+.organization-node-icon,
+.inventory-icon {
+ display: grid;
+ width: 2.4rem;
+ height: 2.4rem;
+ place-items: center;
+ border-radius: 0.65rem;
+ background: #30294e;
+ color: #c8bdf6;
+ font-size: 0.72rem;
+ font-weight: 800;
+}
+
+.organization-node > span:last-of-type {
+ display: grid;
+ min-width: 0;
+ gap: 0.1rem;
+}
+
+.organization-node small {
+ color: #8e79e7;
+ font-size: 0.55rem;
+ font-style: normal;
+ font-weight: 800;
+ letter-spacing: 0.09em;
+ text-transform: uppercase;
+}
+
+.organization-node strong {
+ overflow: hidden;
+ color: #f0f1f5;
+ font-size: 0.78rem;
+ text-overflow: ellipsis;
+ white-space: nowrap;
+}
+
+.organization-node em {
+ overflow: hidden;
+ color: #7d8598;
+ font-size: 0.58rem;
+ font-style: normal;
+ text-overflow: ellipsis;
+ text-transform: capitalize;
+ white-space: nowrap;
+}
+
+.organization-node .react-flow__handle {
+ width: 0.55rem;
+ height: 0.55rem;
+ border: 2px solid #11141c;
+ background: #8b71ed;
+}
+
+.canvas-inventory {
+ display: flex;
+ flex-direction: column;
+ gap: 0.85rem;
+ border-left: 1px solid #2b3040;
+}
+
+.inventory-heading {
+ display: flex;
+ align-items: flex-start;
+ justify-content: space-between;
+ gap: 0.5rem;
+}
+
+.inventory-heading .edit-text { white-space: nowrap; }
+
+.inventory-search input {
+ width: 100%;
+ box-sizing: border-box;
+ padding: 0.65rem 0.7rem;
+ border: 1px solid #303546;
+ border-radius: 0.55rem;
+ outline: 0;
+ background: #0c0f16;
+ color: #e9eaf0;
+}
+
+.inventory-search input:focus { border-color: #8063ec; }
+
+.inventory-filters {
+ display: flex;
+ flex-wrap: wrap;
+ gap: 0.3rem;
+}
+
+.inventory-filters button {
+ padding: 0.35rem 0.48rem;
+ border: 1px solid #303546;
+ border-radius: 999px;
+ background: transparent;
+ color: #858da1;
+ font-size: 0.58rem;
+}
+
+.inventory-filters button.active { border-color: #745ed0; background: #292342; color: #d8cff8; }
+
+.inventory-list {
+ display: grid;
+ align-content: start;
+ gap: 0.35rem;
+ overflow-y: auto;
+ max-height: 23rem;
+}
+
+.inventory-list > button {
+ display: grid;
+ grid-template-columns: 2rem minmax(0, 1fr);
+ gap: 0.6rem;
+ align-items: center;
+ padding: 0.55rem;
+ border: 1px solid transparent;
+ background: transparent;
+ color: #e3e5eb;
+ text-align: left;
+}
+
+.inventory-list > button:hover,
+.inventory-list > button.active { border-color: #3a3554; background: #1c1929; }
+.inventory-list .inventory-icon { width: 2rem; height: 2rem; font-size: 0.6rem; }
+.inventory-list > button > span:last-child { display: grid; min-width: 0; gap: 0.15rem; }
+.inventory-list strong { overflow: hidden; font-size: 0.7rem; text-overflow: ellipsis; white-space: nowrap; }
+.inventory-list small { overflow: hidden; color: #747c8f; font-size: 0.58rem; text-overflow: ellipsis; text-transform: capitalize; white-space: nowrap; }
+.inventory-list > p { color: #777f92; font-size: 0.7rem; }
+
+.inventory-selection {
+ display: grid;
+ gap: 0.35rem;
+ margin-top: auto;
+ padding: 0.85rem;
+ border: 1px solid #302b46;
+ border-radius: 0.7rem;
+ background: #171522;
+}
+
+.inventory-selection span { color: #9c89e8; font-size: 0.58rem; font-weight: 800; letter-spacing: 0.08em; text-transform: uppercase; }
+.inventory-selection strong { font-size: 0.8rem; }
+.inventory-selection p { margin: 0; color: #7b8396; font-size: 0.65rem; text-transform: capitalize; }
+
+.inventory-selection-actions {
+ display: flex;
+ gap: 0.4rem;
+ padding-top: 0.35rem;
+ border-top: 1px solid #332d48;
+}
+
+.inventory-selection-actions button { flex: 1; }
+
+.canvas-notice {
+ position: absolute;
+ right: 1rem;
+ bottom: 1rem;
+ z-index: 7;
+ display: flex;
+ align-items: center;
+ gap: 0.8rem;
+ padding: 0.7rem 0.8rem;
+ border: 1px solid #4c4274;
+ border-radius: 0.7rem;
+ background: #201b31;
+ color: #d8d1f2;
+ font-size: 0.68rem;
+ box-shadow: 0 15px 40px rgb(0 0 0 / 35%);
+}
+
+.canvas-notice button { padding: 0; border: 0; background: transparent; color: #a8a0bd; }
+
+.quick-create-backdrop {
+ position: fixed;
+ inset: 0;
+ z-index: 50;
+ display: grid;
+ place-items: center;
+ padding: 1rem;
+ background: rgb(5 7 11 / 74%);
+ backdrop-filter: blur(6px);
+}
+
+.quick-create-card {
+ display: flex;
+ max-height: min(85vh, 48rem);
+ width: min(100%, 27rem);
+ flex-direction: column;
+ gap: 1rem;
+ overflow: hidden;
+ padding: 1.4rem;
+ border: 1px solid #403761;
+ border-radius: 1rem;
+ background: linear-gradient(145deg, #1a1c28, #11141c);
+ box-shadow: 0 32px 100px rgb(0 0 0 / 55%);
+}
+
+.quick-create-card h3 { margin: 0.15rem 0 0.25rem; font-size: 1.4rem; }
+.quick-create-heading { display: grid; grid-template-columns: auto minmax(0, 1fr); gap: 1rem; }
+.quick-create-heading > div:last-child > p:last-child { margin: 0; color: #858da1; font-size: 0.75rem; }
+.quick-create-body { display: grid; min-height: 0; overflow-y: auto; gap: 1rem; padding-right: 0.2rem; }
+.quick-create-icon { display: grid; width: 2.8rem; height: 2.8rem; place-items: center; border-radius: 0.7rem; background: #30294e; color: #c8bdf6; font-weight: 800; }
+.quick-create-actions { display: flex; flex: 0 0 auto; justify-content: flex-end; gap: 0.6rem; padding-top: 0.85rem; border-top: 1px solid #2c3040; background: #191c27; }
+.quick-create-actions button { margin: 0; }
+
+.delete-confirmation ul {
+ display: grid;
+ gap: 0.4rem;
+ max-height: 10rem;
+ overflow-y: auto;
+ margin: 0;
+ padding: 0.75rem 0.75rem 0.75rem 1.75rem;
+ border: 1px solid #3b3039;
+ border-radius: 0.7rem;
+ background: #171217;
+ color: #b99da5;
+ font-size: 0.7rem;
+}
+
+.quick-create-icon.danger { background: #562a35; color: #ffc1cd; }
+
+.delete-button {
+ border-color: #91445a;
+ background: #7b3549;
+}
+
+.delete-button:hover { background: #934057; }
+
+.impact-testing-shell {
+ display: grid;
+ grid-template-columns: minmax(18rem, 0.65fr) minmax(0, 1.35fr);
+ gap: 1px;
+ overflow: hidden;
+ border: 1px solid #2b3040;
+ border-radius: 1rem;
+ background: #2b3040;
+}
+
+.impact-explorer {
+ display: grid;
+ grid-template-columns: minmax(15rem, 0.42fr) minmax(0, 1.58fr);
+ gap: 1px;
+ overflow: hidden;
+ border: 1px solid #2b3040;
+ border-radius: 1rem;
+ background: #2b3040;
+ box-shadow: 0 28px 80px rgb(0 0 0 / 18%);
+}
+
+.workflow-choice-panel,
+.impact-explorer-main {
+ min-width: 0;
+ background: #11141c;
+}
+
+.workflow-choice-panel {
+ display: flex;
+ flex-direction: column;
+ gap: 1.1rem;
+ padding: clamp(1.1rem, 2.5vw, 1.6rem);
+}
+
+.workflow-choice-panel h3,
+.workflow-scenario-graph h3,
+.scenario-composer h3,
+.impact-preview-result h3 {
+ margin: 0.2rem 0 0.4rem;
+ font-size: 1.25rem;
+}
+
+.workflow-choice-panel > div:first-child > p:last-child,
+.scenario-composer > div:first-child > p:last-child {
+ margin: 0;
+ color: #858da1;
+ font-size: 0.75rem;
+ line-height: 1.55;
+}
+
+.workflow-choice-list {
+ display: grid;
+ gap: 0.55rem;
+}
+
+.workflow-choice-list button {
+ display: grid;
+ gap: 0.65rem;
+ padding: 0.8rem;
+ border: 1px solid #303546;
+ border-radius: 0.7rem;
+ background: #171a24;
+ color: #dfe1e8;
+ text-align: left;
+}
+
+.workflow-choice-list button.active {
+ border-color: #8063ec;
+ background: #211d33;
+ box-shadow: inset 3px 0 #8d74ee;
+}
+
+.workflow-choice-list button span {
+ display: grid;
+ gap: 0.25rem;
+}
+
+.workflow-choice-list button small { color: #7f879b; font-size: 0.67rem; }
+.workflow-choice-list button em,
+.scenario-choice-list button em {
+ justify-self: start;
+ padding: 0.22rem 0.42rem;
+ border-radius: 999px;
+ font-size: 0.58rem;
+ font-style: normal;
+ font-weight: 800;
+ letter-spacing: 0.04em;
+ text-transform: uppercase;
+}
+
+.workflow-choice-list em.danger,
+.scenario-choice-list em.danger { background: #40202a; color: #f5a9b7; }
+.workflow-choice-list em.warning,
+.scenario-choice-list em.warning { background: #3b311b; color: #f5d47f; }
+.workflow-choice-list em.safe,
+.scenario-choice-list em.safe { background: #173428; color: #8de0b5; }
+.workflow-choice-list em.neutral { background: #282d3a; color: #abb2c4; }
+
+.workflow-choice-panel > .secondary-button {
+ margin-top: auto;
+}
+
+.impact-explorer-main {
+ display: grid;
+ gap: 1px;
+ background: #2b3040;
+}
+
+.outcome-explanation {
+ display: grid;
+ grid-template-columns: auto minmax(0, 1fr) auto;
+ align-items: start;
+ gap: 0.85rem;
+ padding: 0.9rem 1.1rem;
+ border-left: 4px solid #4ade80;
+ background: #152b21;
+ color: #dff9e8;
+ box-shadow: 0 16px 38px rgb(0 0 0 / 30%);
+ animation: outcome-in 180ms ease-out;
+}
+
+.outcome-explanation.degraded { border-left-color: #fbbf24; background: #332a17; color: #fff2bd; }
+.outcome-explanation.blocked { border-left-color: #fb7185; background: #351923; color: #ffe0e6; }
+.outcome-explanation-icon { display: grid; width: 1.8rem; height: 1.8rem; place-items: center; border-radius: 50%; background: rgb(255 255 255 / 9%); font-weight: 900; }
+.outcome-explanation div { display: grid; gap: 0.25rem; }
+.outcome-explanation p { margin: 0; color: inherit; font-size: 0.76rem; line-height: 1.5; }
+.outcome-explanation small { color: rgb(255 255 255 / 68%); font-size: 0.66rem; }
+.outcome-explanation > button { padding: 0.1rem 0.35rem; border: 0; background: transparent; color: inherit; font-size: 1.15rem; }
+
+@keyframes outcome-in {
+ from { opacity: 0; transform: translateY(-0.35rem); }
+ to { opacity: 1; transform: translateY(0); }
+}
+
+.workflow-scenario-graph,
+.scenario-composer,
+.impact-preview-result {
+ min-width: 0;
+ padding: clamp(1.1rem, 2.5vw, 1.6rem);
+ background: #11141c;
+}
+
+.scenario-graph-heading {
+ display: flex;
+ align-items: flex-start;
+ justify-content: space-between;
+ gap: 1rem;
+}
+
+.scenario-legend {
+ display: flex;
+ flex-wrap: wrap;
+ gap: 0.7rem;
+ color: #9ba2b4;
+ font-size: 0.64rem;
+}
+
+.scenario-legend span { display: inline-flex; align-items: center; gap: 0.32rem; }
+.scenario-legend i { width: 0.48rem; height: 0.48rem; border-radius: 50%; }
+.scenario-legend i.selected { background: #a78bfa; }
+.scenario-legend i.safe { background: #4ade80; }
+.scenario-legend i.degraded { background: #fbbf24; }
+.scenario-legend i.blocked { background: #fb7185; }
+
+.scenario-graph-help {
+ margin: 0 0 0.8rem;
+ color: #7f879b;
+ font-size: 0.72rem;
+}
+
+.scenario-graph-quick-action {
+ display: flex;
+ align-items: center;
+ justify-content: space-between;
+ gap: 0.8rem;
+ margin-bottom: 0.75rem;
+ padding: 0.55rem 0.65rem;
+ border: 1px solid #3b3550;
+ border-radius: 0.65rem;
+ background: #191624;
+ color: #b9b0d8;
+ font-size: 0.68rem;
+}
+
+.scenario-graph-quick-action button {
+ padding: 0.45rem 0.65rem;
+ font-size: 0.66rem;
+}
+
+.scenario-context-menu {
+ position: fixed;
+ z-index: 100;
+ display: grid;
+ width: min(16rem, calc(100vw - 2rem));
+ gap: 0.35rem;
+ padding: 0.65rem;
+ border: 1px solid #504672;
+ border-radius: 0.7rem;
+ background: #1b1827;
+ box-shadow: 0 18px 55px rgb(0 0 0 / 48%);
+}
+
+.scenario-context-menu > strong { font-size: 0.76rem; }
+.scenario-context-menu > span { color: #858da1; font-size: 0.62rem; }
+.scenario-context-menu button {
+ padding: 0.55rem 0.65rem;
+ border-color: #383348;
+ background: #252132;
+ color: #ddd8ef;
+ font-size: 0.68rem;
+ text-align: left;
+}
+
+.workflow-scenario-canvas {
+ height: 34rem;
+ overflow: hidden;
+ border: 1px solid #2f3444;
+ border-radius: 0.75rem;
+ background: #0d1017;
+}
+
+.scenario-graph-node {
+ display: grid;
+ width: 11rem;
+ gap: 0.22rem;
+ padding: 0.72rem 0.78rem;
+ border: 1px solid #4a5267;
+ border-radius: 0.65rem;
+ background: #191d28;
+ color: #edf0f7;
+ box-shadow: 0 8px 24px rgb(0 0 0 / 26%);
+ cursor: pointer;
+ transition: border-color 150ms ease, background 150ms ease, box-shadow 150ms ease;
+}
+
+.scenario-graph-node small { color: #858da1; font-size: 0.52rem; font-weight: 800; letter-spacing: 0.09em; text-transform: uppercase; }
+.scenario-graph-node strong { overflow: hidden; font-size: 0.75rem; text-overflow: ellipsis; white-space: nowrap; }
+.scenario-graph-node span { color: #959db0; font-size: 0.61rem; }
+.scenario-graph-node.selected { border-color: #a78bfa; background: #28203d; box-shadow: 0 0 0 2px rgb(167 139 250 / 14%); }
+.scenario-graph-node.removed,
+.scenario-graph-node.blocked { border-color: #fb7185; background: #351923; }
+.scenario-graph-node.degraded { border-color: #fbbf24; background: #332a17; }
+.scenario-graph-node.safe { border-color: #4ade80; background: #152b21; }
+.scenario-graph-node.workflow { width: 12rem; }
+.scenario-graph-node.active { outline: 2px solid rgb(255 255 255 / 18%); outline-offset: 2px; }
+.scenario-graph-node .react-flow__handle { width: 0.42rem; height: 0.42rem; border: 1px solid #11141c; background: currentcolor; }
+
+.scenario-composer {
+ display: grid;
+ gap: 1rem;
+}
+
+.scenario-choice-group {
+ display: grid;
+ gap: 0.55rem;
+}
+
+.scenario-choice-group > strong { color: #cbd0dc; font-size: 0.72rem; }
+.scenario-choice-list,
+.member-choice-list {
+ display: grid;
+ grid-template-columns: repeat(auto-fit, minmax(11rem, 1fr));
+ gap: 0.55rem;
+}
+
+.scenario-choice-list button,
+.member-choice-list button {
+ display: grid;
+ gap: 0.3rem;
+ padding: 0.7rem;
+ border: 1px solid #303546;
+ border-radius: 0.65rem;
+ background: #171a24;
+ color: #dfe1e8;
+ text-align: left;
+}
+
+.scenario-choice-list button.active,
+.member-choice-list button.active {
+ border-color: #8063ec;
+ background: #211d33;
+}
+
+.scenario-choice-list button small,
+.member-choice-list button small { min-height: 1.9em; color: #858da1; font-size: 0.64rem; line-height: 1.45; }
+
+.scenario-action-summary {
+ display: grid;
+ gap: 0.22rem;
+ padding: 0.9rem;
+ border: 1px solid #3b3550;
+ border-radius: 0.7rem;
+ background: #191624;
+}
+
+.scenario-action-summary span { color: #9c89e8; font-size: 0.58rem; font-weight: 800; letter-spacing: 0.08em; text-transform: uppercase; }
+.scenario-action-summary strong { font-size: 0.88rem; }
+.scenario-action-summary p { margin: 0; color: #7f879b; font-size: 0.68rem; }
+.scenario-actions { display: flex; flex-wrap: wrap; gap: 0.65rem; }
+.scenario-actions .secondary-button { margin-top: 0; }
+
+.impact-preview-result .impact-preview-summary { margin-bottom: 1rem; }
+
+.impact-test-controls,
+.impact-test-result {
+ min-width: 0;
+ background: #11141c;
+}
+
+.impact-test-controls {
+ display: flex;
+ flex-direction: column;
+ gap: 1rem;
+ padding: clamp(1.25rem, 3vw, 2rem);
+}
+
+.impact-test-controls h3,
+.impact-preview-summary h3,
+.impact-testing-empty h3 {
+ margin: 0.2rem 0 0.45rem;
+ font-size: 1.45rem;
+}
+
+.impact-test-controls > div:first-child > p:last-child,
+.impact-preview-summary p,
+.impact-testing-empty > p:last-of-type {
+ margin: 0;
+ color: #858da1;
+ font-size: 0.78rem;
+ line-height: 1.6;
+}
+
+.continuity-signal {
+ display: grid;
+ gap: 0.25rem;
+ padding: 0.85rem;
+ border: 1px solid #345349;
+ border-radius: 0.7rem;
+ background: #14221e;
+}
+
+.continuity-signal.critical { border-color: #704352; background: #27171e; }
+.continuity-signal strong { color: #9cddc1; font-size: 0.75rem; }
+.continuity-signal.critical strong { color: #f6aebb; }
+.continuity-signal span { color: #89958f; font-size: 0.67rem; }
+
+.impact-test-result {
+ padding: clamp(1.25rem, 3vw, 2rem);
+}
+
+.impact-result-placeholder {
+ display: grid;
+ min-height: 35rem;
+ place-content: center;
+ justify-items: center;
+ color: #858da1;
+ text-align: center;
+}
+
+.impact-result-placeholder > span,
+.impact-testing-empty > span {
+ display: grid;
+ width: 3.25rem;
+ height: 3.25rem;
+ margin-bottom: 1rem;
+ place-items: center;
+ border: 1px solid #4b426b;
+ border-radius: 50%;
+ background: #211d32;
+ color: #a994f0;
+ font-size: 1.3rem;
+}
+
+.impact-result-placeholder strong { color: #dfe1e8; }
+.impact-result-placeholder p { max-width: 24rem; margin: 0.45rem 0 0; font-size: 0.75rem; line-height: 1.6; }
+
+.impact-preview-summary {
+ display: flex;
+ align-items: flex-start;
+ justify-content: space-between;
+ gap: 1rem;
+ margin-bottom: 1rem;
+}
+
+.impact-preview-counts {
+ display: grid;
+ grid-template-columns: repeat(3, 1fr);
+ gap: 1px;
+ overflow: hidden;
+ margin-bottom: 1rem;
+ border: 1px solid #2d3241;
+ border-radius: 0.75rem;
+ background: #2d3241;
+}
+
+.impact-preview-counts article {
+ display: grid;
+ gap: 0.2rem;
+ padding: 0.85rem;
+ background: #151821;
+}
+
+.impact-preview-counts strong { font-size: 1.25rem; }
+.impact-preview-counts span { color: #7d8598; font-size: 0.62rem; }
+.impact-test-result .graph-panel { margin-top: 0; }
+
+.impact-testing-empty {
+ display: grid;
+ min-height: 28rem;
+ place-content: center;
+ justify-items: center;
+ padding: 2rem;
+ border: 1px solid #2b3040;
+ border-radius: 1rem;
+ background: #11141c;
+ text-align: center;
+}
+
+.impact-testing-empty > p:last-of-type { max-width: 32rem; margin-bottom: 1.25rem; }
+.impact-testing-empty.warning > span { border-color: #6e4854; background: #311a22; color: #f5abb9; }
+
+.sr-only {
+ position: absolute;
+ width: 1px;
+ height: 1px;
+ overflow: hidden;
+ clip: rect(0, 0, 0, 0);
+ white-space: nowrap;
+}
+
+@media (max-width: 72rem) {
+ .canvas-builder { grid-template-columns: 11rem minmax(30rem, 1fr); }
+ .canvas-inventory { grid-column: 1 / -1; min-height: 15rem; border-top: 1px solid #2b3040; border-left: 0; }
+ .inventory-list { grid-template-columns: repeat(3, 1fr); max-height: none; }
+ .inventory-selection { display: none; }
+}
+
+@media (max-width: 60rem) {
+ .workspace-choice-grid {
+ grid-template-columns: 1fr;
+ }
+
+ .workspace-choice {
+ min-height: 0;
+ }
+
+ .workspace-choice > div > p:last-child {
+ max-width: 40rem;
+ }
+
+ .workspace-choice form,
+ .workspace-choice > button,
+ .workspace-mini-stats {
+ margin-top: 2rem;
+ }
+
+ .draft-summary {
+ grid-template-columns: repeat(3, 1fr);
+ }
+
+ .editor-layout,
+ .roles-layout {
+ grid-template-columns: 1fr;
+ }
+
+ .impact-testing-shell,
+ .impact-explorer { grid-template-columns: 1fr; }
+
+ .workflow-choice-panel { display: grid; }
+ .workflow-choice-list { grid-template-columns: repeat(auto-fit, minmax(12rem, 1fr)); }
+ .workflow-choice-panel > .secondary-button { justify-self: start; margin-top: 0; }
+
+ .editor-form > button {
+ margin-top: 1rem;
+ }
+
+ .canvas-builder { grid-template-columns: 1fr; }
+ .canvas-toolbox { border-right: 0; border-bottom: 1px solid #2b3040; }
+ .canvas-palette { grid-template-columns: repeat(4, 1fr); }
+ .canvas-help { display: none; }
+ .canvas-dropzone { min-height: 32rem; }
+}
+
+@media (max-width: 36rem) {
+ .workspace-home-header {
+ padding: 0 1rem;
+ }
+
+ .workspace-home-main,
+ .draft-main {
+ width: min(100% - 1.25rem, 76rem);
+ }
+
+ .draft-summary {
+ grid-template-columns: repeat(2, 1fr);
+ }
+
+ .builder-next-card {
+ grid-template-columns: 1fr;
+ }
+
+ .builder-next-card .choice-number {
+ display: none;
+ }
+
+ .editor-heading {
+ align-items: flex-start;
+ flex-direction: column;
+ }
+
+ .risk-callout { grid-template-columns: auto 1fr; }
+ .risk-callout button { grid-column: 1 / -1; }
+ .canvas-toolbar { align-items: flex-start; flex-direction: column; }
+ .canvas-toolbar-actions { width: 100%; flex-wrap: wrap; }
+ .canvas-toolbar-actions label { flex: 1; }
+ .canvas-toolbar-actions select { width: 100%; max-width: none; }
+
+ .editor-view-switch { width: 100%; }
+ .editor-view-switch button { flex: 1; }
+ .scenario-graph-heading { align-items: flex-start; flex-direction: column; }
+ .scenario-graph-quick-action { align-items: flex-start; flex-direction: column; }
+ .workflow-scenario-canvas { height: 27rem; }
+ .scenario-choice-list,
+ .member-choice-list { grid-template-columns: 1fr; }
+ .canvas-palette { grid-template-columns: repeat(2, 1fr); }
+ .inventory-list { grid-template-columns: 1fr; }
+
+ .editor-stages button {
+ grid-template-columns: 1fr;
+ gap: 0.25rem;
+ }
+
+ .editor-stages button > span,
+ .editor-stages button small {
+ display: none;
+ }
+
+ .field-row {
+ grid-template-columns: 1fr;
}
}
@@ -885,7 +2286,7 @@ button:hover {
}
button:disabled {
- cursor: wait;
+ cursor: not-allowed;
opacity: 0.65;
}
diff --git a/frontend/src/App.test.tsx b/frontend/src/App.test.tsx
index 8f495f6..be7a43f 100644
--- a/frontend/src/App.test.tsx
+++ b/frontend/src/App.test.tsx
@@ -1,12 +1,14 @@
import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
-import { cleanup, render, screen } from '@testing-library/react'
+import { cleanup, fireEvent, render, screen, within } from '@testing-library/react'
import userEvent from '@testing-library/user-event'
import { afterEach, describe, expect, it, vi } from 'vitest'
import App from './App'
+import type { DraftCatalog } from './api/draftCatalog'
afterEach(() => {
cleanup()
vi.restoreAllMocks()
+ localStorage.clear()
})
function renderApp() {
@@ -131,6 +133,7 @@ describe('App', () => {
const url = input.toString()
if (url.endsWith('/api/v1/workspaces') && !init?.method) return jsonResponse(workspaceFixture)
if (url.endsWith('/clones') && init?.method === 'POST') return jsonResponse(clonedWorkspaceFixture, 201)
+ if (url.endsWith('/catalog')) return jsonResponse(clonedCatalogFixture)
return new Response(null, { status: 404 })
})
@@ -141,8 +144,167 @@ describe('App', () => {
expect(await screen.findByRole('heading', { name: 'Harborline Sandbox' })).toBeInTheDocument()
expect(screen.getByText('Draft · not yet published')).toBeInTheDocument()
expect(screen.getByText(/fresh identity/)).toBeInTheDocument()
- expect(screen.getByLabelText('Draft catalog summary')).toHaveTextContent('25')
+ expect(screen.getByLabelText('Draft catalog summary')).toHaveTextContent('1members')
+ expect(await screen.findByRole('heading', { name: 'Map how your organization works' })).toBeInTheDocument()
+ expect(await screen.findByLabelText('Organization relationship canvas')).toBeInTheDocument()
+ expect(screen.getByLabelText('Organization inventory')).toHaveTextContent('Finance Approver')
+ expect(screen.getByRole('button', { name: 'Show full map' })).toBeInTheDocument()
+ await user.click(screen.getByRole('button', { name: 'Detailed inventory' }))
+ expect(screen.getByRole('button', { name: /Teams/ })).toHaveAttribute('aria-current', 'step')
})
+
+ it('builds a blank draft through teams, members, workflows, impact testing, and shared roles', async () => {
+ const user = userEvent.setup()
+ let catalog: DraftCatalog = structuredClone(blankCatalogFixture)
+ vi.spyOn(globalThis, 'fetch').mockImplementation(async (input, init) => {
+ const url = input.toString()
+ if (url.endsWith('/api/v1/workspaces') && !init?.method) return jsonResponse(workspaceFixture)
+ if (url.endsWith('/api/v1/workspaces') && init?.method === 'POST') return jsonResponse(blankWorkspaceFixture, 201)
+ if (url.endsWith('/catalog') && !init?.method) return jsonResponse(catalog)
+ if (url.endsWith('/catalog/teams') && init?.method === 'POST') {
+ const input = JSON.parse(String(init.body)) as { name: string; department: string }
+ catalog = { ...catalog, teams: [{ id: 'team-1', name: input.name, department: input.department, memberCount: 0 }] }
+ return jsonResponse(catalog)
+ }
+ if (url.endsWith('/catalog/members') && init?.method === 'POST') {
+ const input = JSON.parse(String(init.body)) as { name: string }
+ const memberNumber = catalog.members.length + 1
+ const member = { id: `member-${memberNumber}`, teamId: 'team-1', employeeNumber: null, name: input.name, email: null, status: 'ACTIVE' as const, region: 'NORTH_AMERICA' as const, shift: 'DAY' as const, roleIds: [] }
+ catalog = { ...catalog, teams: [{ ...catalog.teams[0], memberCount: memberNumber }], members: [...catalog.members, member] }
+ return jsonResponse(catalog)
+ }
+ if (url.endsWith('/catalog/roles') && init?.method === 'POST') {
+ const input = JSON.parse(String(init.body)) as { name: string; description: string; sensitivity: DraftCatalog['roles'][number]['sensitivity'] }
+ catalog = { ...catalog, roles: [{ id: 'role-1', name: input.name, description: input.description, sensitivity: input.sensitivity, ownerMemberId: null, memberCount: 0 }] }
+ return jsonResponse(catalog)
+ }
+ if (url.endsWith('/catalog/members/member-1') && init?.method === 'PUT') {
+ const input = JSON.parse(String(init.body)) as Omit
+ catalog = { ...catalog, members: catalog.members.map((member) => member.id === 'member-1' ? { ...member, ...input } : member) }
+ return jsonResponse(catalog)
+ }
+ if (url.endsWith('/catalog/roles/role-1') && init?.method === 'PUT') {
+ const input = JSON.parse(String(init.body)) as { name: string; description: string; sensitivity: DraftCatalog['roles'][number]['sensitivity']; ownerMemberId: string | null }
+ catalog = { ...catalog, roles: [{ ...catalog.roles[0], ...input }] }
+ return jsonResponse(catalog)
+ }
+ if (url.match(/\/members\/[^/]+\/roles$/) && init?.method === 'PUT') {
+ const memberId = url.match(/\/members\/([^/]+)\/roles$/)![1]
+ const input = JSON.parse(String(init.body)) as { roleIds: string[] }
+ const members = catalog.members.map((member) => member.id === memberId ? { ...member, roleIds: input.roleIds } : member)
+ const roles = catalog.roles.map((role) => ({ ...role, memberCount: members.filter((member) => member.roleIds.includes(role.id)).length }))
+ catalog = { ...catalog, members, roles }
+ return jsonResponse(catalog)
+ }
+ if (url.endsWith('/catalog/workflows/quick') && init?.method === 'POST') {
+ const input = JSON.parse(String(init.body)) as { name: string; criticality: DraftCatalog['workflows'][number]['criticality']; requirementName: string }
+ catalog = { ...catalog, workflows: [{ id: 'workflow-1', name: input.name, criticality: input.criticality, quickManaged: true, requirements: [{ id: 'requirement-1', name: input.requirementName, position: 1, minimumActors: 1, resilienceTarget: 1, requiredDepartment: null, requiredRegion: null, requiredShift: null, roleIds: ['role-1'] }] }] }
+ return jsonResponse(catalog)
+ }
+ if (url.endsWith('/impact-previews') && init?.method === 'POST') return jsonResponse(customDraftImpactFixture)
+ if (url.endsWith('/catalog/workflows/workflow-1') && init?.method === 'DELETE') {
+ catalog = { ...catalog, workflows: [] }
+ return jsonResponse(catalog)
+ }
+ return new Response(null, { status: 404 })
+ })
+
+ renderApp()
+ await user.type(await screen.findByLabelText('Organization name'), 'Atlas Systems')
+ await user.click(screen.getByRole('button', { name: 'Start blank' }))
+ expect(await screen.findByRole('heading', { name: 'Map how your organization works' })).toBeInTheDocument()
+ expect(screen.getByRole('button', { name: 'Add Member' })).toBeDisabled()
+
+ await user.click(screen.getByRole('button', { name: 'Add Team' }))
+ await user.type(screen.getByLabelText('Team name'), 'Platform')
+ await user.clear(screen.getByLabelText('Department (optional)'))
+ await user.type(screen.getByLabelText('Department (optional)'), 'Engineering')
+ await user.click(screen.getByRole('button', { name: 'Create team' }))
+ expect(await screen.findByText('Team created')).toBeInTheDocument()
+
+ await user.click(screen.getByRole('button', { name: 'Add Member' }))
+ await user.type(screen.getByLabelText('Member name'), 'Maya Singh')
+ expect(screen.getByText(/Employee reference ID and work email are optional/)).toBeInTheDocument()
+ await user.click(screen.getByRole('button', { name: 'Create member' }))
+ expect(await screen.findByText('Member created')).toBeInTheDocument()
+
+ await user.click(screen.getByRole('button', { name: 'Add Role' }))
+ await user.type(screen.getByLabelText('Role name'), 'Release Manager')
+ await user.selectOptions(screen.getByLabelText('Sensitivity'), 'HIGH')
+ expect(screen.getByRole('checkbox', { name: 'Maya Singh' })).not.toBeChecked()
+ expect(screen.getByRole('button', { name: 'Create role without holders' })).toBeInTheDocument()
+ await user.click(screen.getByRole('checkbox', { name: 'Maya Singh' }))
+ await user.click(screen.getByRole('button', { name: 'Create role' }))
+ expect(await screen.findByText('Role created')).toBeInTheDocument()
+
+ await user.click(screen.getByRole('button', { name: 'Add Workflow' }))
+ await user.type(screen.getByLabelText('Workflow name'), 'Production Deployment')
+ await user.selectOptions(screen.getByLabelText('Business criticality'), 'CRITICAL')
+ await user.click(screen.getByRole('button', { name: 'Create workflow' }))
+ expect(await screen.findByText('Workflow created')).toBeInTheDocument()
+ expect(screen.getByLabelText('Organization inventory')).toHaveTextContent('Production Deployment')
+ expect(screen.getByLabelText('Organization relationship canvas')).toBeInTheDocument()
+ expect(screen.getByText('5 objects · 4 connections')).toBeInTheDocument()
+ expect(screen.getByLabelText('Team Platform')).toBeInTheDocument()
+ expect(screen.getByLabelText('Member Maya Singh')).toBeInTheDocument()
+ expect(screen.getByLabelText('Role Release Manager')).toBeInTheDocument()
+ expect(screen.getByLabelText('Responsibility Release Manager responsibility')).toBeInTheDocument()
+ expect(screen.getByLabelText('Workflow Production Deployment')).toBeInTheDocument()
+ expect(screen.getByLabelText('Continuity risks found')).toHaveTextContent('critical coverage gap')
+
+ await user.click(screen.getByRole('button', { name: 'Test this risk' }))
+ expect(await screen.findByRole('heading', { name: 'Test a change before it happens' })).toBeInTheDocument()
+ expect(await screen.findByLabelText('Production Deployment baseline and impact graph')).toBeInTheDocument()
+ expect(screen.getByRole('button', { name: /Production Deployment.*would block/ })).toHaveAttribute('aria-pressed', 'true')
+ fireEvent.contextMenu(screen.getByLabelText(/Member Maya Singh.*context menu/))
+ expect(screen.getByRole('menu', { name: 'What-if actions for Maya Singh' })).toBeInTheDocument()
+ await user.click(screen.getByRole('menuitem', { name: 'Test losing Release Manager' }))
+ expect(await screen.findByText('This responsibility is now blocked')).toBeInTheDocument()
+ expect(screen.getByText(/Maya Singh was the only eligible holder/)).toBeInTheDocument()
+ expect(await screen.findByRole('heading', { name: 'A workflow would be blocked' })).toBeInTheDocument()
+ expect(screen.getByLabelText('Production Deployment baseline and impact graph')).toBeInTheDocument()
+ expect(screen.getByRole('button', { name: 'Reset to baseline' })).toBeInTheDocument()
+
+ await user.click(screen.getByRole('button', { name: 'Organization map' }))
+ const inventory = screen.getByLabelText('Organization inventory')
+ await user.click(within(inventory).getByRole('button', { name: /Production Deployment/ }))
+ await user.click(within(inventory).getByRole('button', { name: 'Delete object' }))
+ const dialog = screen.getByRole('dialog', { name: 'Remove Production Deployment?' })
+ await user.click(within(dialog).getByRole('button', { name: 'Delete object' }))
+ expect(await screen.findByText('Workflow deleted')).toBeInTheDocument()
+
+ await user.click(screen.getByRole('button', { name: 'Add Member' }))
+ await user.type(screen.getByLabelText('Member name'), 'Arjun Mehta')
+ await user.click(screen.getByRole('button', { name: 'Create member' }))
+ expect(await screen.findByText('Member created')).toBeInTheDocument()
+
+ await user.click(screen.getByRole('button', { name: 'Add Role' }))
+ await user.type(screen.getByLabelText('Role name'), 'Release Manager')
+ await user.click(screen.getByRole('checkbox', { name: 'Arjun Mehta' }))
+ await user.click(screen.getByRole('button', { name: 'Assign existing role' }))
+ expect(await screen.findByText('Role assigned')).toBeInTheDocument()
+
+ await user.click(screen.getByRole('button', { name: 'Detailed inventory' }))
+ await user.click(screen.getByRole('button', { name: /Members/ }))
+ const mayaItem = screen.getByText('Maya Singh').closest('article')
+ expect(mayaItem).not.toBeNull()
+ await user.click(within(mayaItem!).getByRole('button', { name: 'Edit' }))
+ await user.type(screen.getByLabelText('Employee reference ID (optional)'), 'ATLAS-01')
+ await user.click(screen.getByRole('button', { name: 'Save member' }))
+ await user.click(screen.getByRole('button', { name: 'Organization map' }))
+ expect(await screen.findByLabelText('Member Maya Singh')).toHaveTextContent('ATLAS-01')
+ const mayaNode = screen.getByLabelText('Member Maya Singh').closest('.react-flow__node')
+ const arjunNode = screen.getByLabelText('Member Arjun Mehta').closest('.react-flow__node')
+ expect(mayaNode?.getAttribute('style')).not.toEqual(arjunNode?.getAttribute('style'))
+ await user.click(screen.getByRole('button', { name: 'Detailed inventory' }))
+ await user.click(screen.getByRole('button', { name: /Roles/ }))
+ expect(await screen.findByText(/2 holders/)).toBeInTheDocument()
+ expect(screen.getByText('Maya Singh, Arjun Mehta')).toBeInTheDocument()
+ await user.click(screen.getByRole('button', { name: 'Edit' }))
+ await user.selectOptions(screen.getByLabelText('Sensitivity'), 'CRITICAL')
+ await user.click(screen.getByRole('button', { name: 'Save role and holders' }))
+ expect(await screen.findByText(/CRITICAL · 2 holders/)).toBeInTheDocument()
+ }, 15000)
})
function jsonResponse(value: unknown, status = 200) {
@@ -176,6 +338,41 @@ const clonedWorkspaceFixture = {
sourceTemplateOrganizationId: workspaceFixture[0].id,
}
+const blankWorkspaceFixture = {
+ ...workspaceFixture[0],
+ id: '90000000-0000-0000-0000-000000000002',
+ slug: 'atlas-systems',
+ name: 'Atlas Systems',
+ status: 'DRAFT',
+ currentVersion: 0,
+ sourceTemplateOrganizationId: null,
+ counts: { teams: 0, members: 0, roles: 0, permissions: 0, capabilities: 0, workflows: 0 },
+}
+
+const blankCatalogFixture: DraftCatalog = {
+ workspaceId: blankWorkspaceFixture.id,
+ teams: [],
+ members: [],
+ roles: [],
+ workflows: [],
+}
+
+const clonedCatalogFixture: DraftCatalog = {
+ workspaceId: clonedWorkspaceFixture.id,
+ teams: [
+ { id: 'team-finance', name: 'Finance Operations', department: 'Finance', memberCount: 5 },
+ ],
+ members: [
+ { id: 'member-priya', teamId: 'team-finance', employeeNumber: 'HC-001', name: 'Priya Sharma', email: 'priya@harborline.test', status: 'ACTIVE', region: 'NORTH_AMERICA', shift: 'EVENING', roleIds: ['role-approver'] },
+ ],
+ roles: [
+ { id: 'role-approver', name: 'Finance Approver', description: 'Approves payments', sensitivity: 'CRITICAL', ownerMemberId: 'member-priya', memberCount: 1 },
+ ],
+ workflows: [
+ { id: 'workflow-payment', name: 'Vendor Payment', criticality: 'CRITICAL', quickManaged: false, requirements: [{ id: 'requirement-payment', name: 'Approve payment', position: 1, minimumActors: 1, resilienceTarget: 1, requiredDepartment: 'Finance', requiredRegion: null, requiredShift: 'EVENING', roleIds: ['role-approver'] }] },
+ ],
+}
+
const dashboardFixture = {
organization: {
id: '00000000-0000-0000-0000-000000000001',
@@ -430,6 +627,30 @@ const simulationFixture = {
},
}
+const customDraftImpactFixture = {
+ ...simulationFixture.result,
+ baselineVersion: 0,
+ changeSet: {
+ type: 'REVOKE_EMPLOYEE_ROLE',
+ employee: { id: 'member-1', name: 'Maya Singh' },
+ role: { id: 'role-1', name: 'Release Manager' },
+ replacementEmployee: null,
+ },
+ executiveSummary: {
+ ...simulationFixture.result.executiveSummary,
+ workflowsBlocked: 1,
+ workflowsDegraded: 0,
+ },
+ workflowImpacts: [
+ {
+ ...simulationFixture.result.workflowImpacts[0],
+ workflowId: 'workflow-1',
+ workflowName: 'Production Deployment',
+ scenarioStatus: 'BLOCKED',
+ },
+ ],
+}
+
const mitigationFixture = {
...simulationFixture,
id: 'b0000000-0000-0000-0000-000000000003',
diff --git a/frontend/src/api/draftCatalog.ts b/frontend/src/api/draftCatalog.ts
new file mode 100644
index 0000000..0501a8f
--- /dev/null
+++ b/frontend/src/api/draftCatalog.ts
@@ -0,0 +1,153 @@
+export type DraftTeam = {
+ id: string
+ name: string
+ department: string
+ memberCount: number
+}
+
+export type DraftMember = {
+ id: string
+ teamId: string
+ employeeNumber: string | null
+ name: string
+ email: string | null
+ status: 'ACTIVE' | 'INACTIVE'
+ region: 'NORTH_AMERICA' | 'EUROPE' | 'ASIA_PACIFIC'
+ shift: 'DAY' | 'EVENING' | 'NIGHT'
+ roleIds: string[]
+}
+
+export type DraftRole = {
+ id: string
+ name: string
+ description: string
+ sensitivity: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL'
+ ownerMemberId: string | null
+ memberCount: number
+}
+
+export type DraftWorkflow = {
+ id: string
+ name: string
+ criticality: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL'
+ requirements: DraftWorkflowRequirement[]
+ quickManaged: boolean
+}
+
+export type DraftWorkflowRequirement = {
+ id: string
+ name: string
+ position: number
+ minimumActors: number
+ resilienceTarget: number
+ requiredDepartment: string | null
+ requiredRegion: DraftMember['region'] | null
+ requiredShift: DraftMember['shift'] | null
+ roleIds: string[]
+}
+
+export type DraftCatalog = {
+ workspaceId: string
+ teams: DraftTeam[]
+ members: DraftMember[]
+ roles: DraftRole[]
+ workflows: DraftWorkflow[]
+}
+
+export type TeamInput = { name: string; department: string }
+export type MemberInput = Omit
+export type RoleInput = Omit
+export type WorkflowRequirementInput = {
+ name: string
+ roleId: string
+ minimumActors: number
+ resilienceTarget: number
+}
+export type QuickWorkflowInput = Pick & {
+ requirementName: string
+ roleId: string
+ minimumActors: number
+ resilienceTarget: number
+}
+
+const apiBaseUrl = import.meta.env.VITE_API_BASE_URL ?? ''
+
+export function fetchDraftCatalog(workspaceId: string, signal?: AbortSignal) {
+ return request(`/api/v1/workspaces/${workspaceId}/catalog`, { signal })
+}
+
+export function createDraftTeam(workspaceId: string, input: TeamInput) {
+ return mutateCatalog(workspaceId, '/teams', 'POST', input)
+}
+
+export function updateDraftTeam(workspaceId: string, teamId: string, input: TeamInput) {
+ return mutateCatalog(workspaceId, `/teams/${teamId}`, 'PUT', input)
+}
+
+export function deleteDraftTeam(workspaceId: string, teamId: string) {
+ return mutateCatalog(workspaceId, `/teams/${teamId}`, 'DELETE')
+}
+
+export function createDraftMember(workspaceId: string, input: MemberInput) {
+ return mutateCatalog(workspaceId, '/members', 'POST', input)
+}
+
+export function updateDraftMember(workspaceId: string, memberId: string, input: MemberInput) {
+ return mutateCatalog(workspaceId, `/members/${memberId}`, 'PUT', input)
+}
+
+export function deleteDraftMember(workspaceId: string, memberId: string) {
+ return mutateCatalog(workspaceId, `/members/${memberId}`, 'DELETE')
+}
+
+export function createDraftRole(workspaceId: string, input: RoleInput) {
+ return mutateCatalog(workspaceId, '/roles', 'POST', input)
+}
+
+export function updateDraftRole(workspaceId: string, roleId: string, input: RoleInput) {
+ return mutateCatalog(workspaceId, `/roles/${roleId}`, 'PUT', input)
+}
+
+export function deleteDraftRole(workspaceId: string, roleId: string) {
+ return mutateCatalog(workspaceId, `/roles/${roleId}`, 'DELETE')
+}
+
+export function replaceMemberRoles(workspaceId: string, memberId: string, roleIds: string[]) {
+ return mutateCatalog(workspaceId, `/members/${memberId}/roles`, 'PUT', { roleIds })
+}
+
+export function createQuickWorkflow(workspaceId: string, input: QuickWorkflowInput) {
+ return mutateCatalog(workspaceId, '/workflows/quick', 'POST', {
+ name: input.name,
+ criticality: input.criticality,
+ requirementName: input.requirementName,
+ roleId: input.roleId,
+ minimumActors: input.minimumActors,
+ resilienceTarget: input.resilienceTarget,
+ })
+}
+
+export function addWorkflowRequirement(workspaceId: string, workflowId: string, input: WorkflowRequirementInput) {
+ return mutateCatalog(workspaceId, `/workflows/${workflowId}/requirements`, 'POST', input)
+}
+
+export function deleteQuickWorkflow(workspaceId: string, workflowId: string) {
+ return mutateCatalog(workspaceId, `/workflows/${workflowId}`, 'DELETE')
+}
+
+function mutateCatalog(workspaceId: string, path: string, method: string, body?: unknown) {
+ return request(`/api/v1/workspaces/${workspaceId}/catalog${path}`, {
+ method,
+ headers: body ? { 'Content-Type': 'application/json' } : undefined,
+ body: body ? JSON.stringify(body) : undefined,
+ })
+}
+
+async function request(path: string, init?: RequestInit): Promise {
+ const response = await fetch(`${apiBaseUrl}${path}`, init)
+ if (!response.ok) {
+ const error = await response.json().catch(() => null) as { message?: string } | null
+ throw new Error(error?.message ?? 'The draft could not be updated')
+ }
+ return response.json() as Promise
+}
diff --git a/frontend/src/api/draftImpact.ts b/frontend/src/api/draftImpact.ts
new file mode 100644
index 0000000..2f169da
--- /dev/null
+++ b/frontend/src/api/draftImpact.ts
@@ -0,0 +1,23 @@
+import type { Simulation } from './simulations'
+
+export type DraftImpactResult = Simulation['result']
+
+const apiBaseUrl = import.meta.env.VITE_API_BASE_URL ?? ''
+
+export async function runDraftImpactPreview(
+ workspaceId: string,
+ memberId: string,
+ roleId: string,
+): Promise {
+ const response = await fetch(`${apiBaseUrl}/api/v1/workspaces/${workspaceId}/impact-previews`, {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({ memberId, roleId }),
+ })
+
+ if (!response.ok) {
+ const error = await response.json().catch(() => null) as { message?: string } | null
+ throw new Error(error?.message ?? 'The impact preview could not be generated')
+ }
+ return response.json() as Promise
+}
diff --git a/frontend/src/components/workspaces/DraftWorkspace.tsx b/frontend/src/components/workspaces/DraftWorkspace.tsx
index 45dc03a..6f3d0af 100644
--- a/frontend/src/components/workspaces/DraftWorkspace.tsx
+++ b/frontend/src/components/workspaces/DraftWorkspace.tsx
@@ -1,4 +1,5 @@
import type { Workspace } from '../../api/workspaces'
+import DraftEditor from './editor/DraftEditor'
type DraftWorkspaceProps = {
workspace: Workspace
@@ -24,23 +25,7 @@ export default function DraftWorkspace({ workspace, onBack }: DraftWorkspaceProp
? 'Your organization is ready. Add its first team and build outward from there.'
: 'Your Harborline copy is ready. Every record has a fresh identity, so changes here cannot affect the example.'}
-
- {Object.entries(workspace.counts).map(([label, value]) => (
-
- {value}
- {label}
-
- ))}
-
-
- Next
-
-
Builder foundation ready
-
{isEmpty ? 'Add your first team' : 'Review teams and members'}
-
The next implementation slice adds the guided Team → Member → Role editor on top of this draft.
-
- {isEmpty ? 'Add team' : 'Open team editor'}
-
+
← Back to workspace choices
diff --git a/frontend/src/components/workspaces/editor/DraftEditor.tsx b/frontend/src/components/workspaces/editor/DraftEditor.tsx
new file mode 100644
index 0000000..2d0a304
--- /dev/null
+++ b/frontend/src/components/workspaces/editor/DraftEditor.tsx
@@ -0,0 +1,427 @@
+import { Children, lazy, Suspense, useEffect, useRef, useState, type FormEvent, type ReactNode } from 'react'
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
+import {
+ addWorkflowRequirement,
+ createDraftMember,
+ createDraftRole,
+ createDraftTeam,
+ createQuickWorkflow,
+ deleteDraftMember,
+ deleteDraftRole,
+ deleteDraftTeam,
+ deleteQuickWorkflow,
+ fetchDraftCatalog,
+ replaceMemberRoles,
+ updateDraftMember,
+ updateDraftRole,
+ updateDraftTeam,
+ type DraftCatalog,
+ type DraftMember,
+} from '../../../api/draftCatalog'
+import { findWorkflowRisks } from './workflowRisks'
+
+const OrganizationCanvas = lazy(() => import('./OrganizationCanvas'))
+const DraftImpactTesting = lazy(() => import('./DraftImpactTesting'))
+
+type EditorStage = 'teams' | 'members' | 'roles' | 'workflows'
+
+export default function DraftEditor({ workspaceId, isTemplateClone }: { workspaceId: string; isTemplateClone: boolean }) {
+ const [stage, setStage] = useState('teams')
+ const [view, setView] = useState<'map' | 'impact' | 'inventory'>('map')
+ const editorRef = useRef(null)
+ const catalogQuery = useQuery({
+ queryKey: ['draft-catalog', workspaceId],
+ queryFn: ({ signal }) => fetchDraftCatalog(workspaceId, signal),
+ })
+
+ if (catalogQuery.isPending) return Loading the draft catalog…
+ if (catalogQuery.isError) {
+ return (
+
+
{catalogQuery.error.message}
+
catalogQuery.refetch()}>Retry
+
+ )
+ }
+
+ const catalog = catalogQuery.data
+ const liveCounts = [
+ { label: 'teams', value: catalog.teams.length },
+ { label: 'members', value: catalog.members.length },
+ { label: 'roles', value: catalog.roles.length },
+ { label: 'workflows', value: catalog.workflows.length },
+ ]
+ const singlePointRisks = findWorkflowRisks(catalog).filter((risk) =>
+ risk.eligibleMembers.length > 0 && risk.eligibleMembers.length === risk.minimumActors,
+ )
+
+ function moveToStage(nextStage: EditorStage) {
+ setStage(nextStage)
+ window.requestAnimationFrame(() => editorRef.current?.scrollIntoView?.({ behavior: 'smooth', block: 'start' }))
+ }
+
+ return (
+
+
+
+
{view === 'impact' ? 'Business continuity lab' : 'Visual organization builder'}
+
{view === 'impact' ? 'Test a change before it happens' : 'Map how your organization works'}
+
+
+ setView('map')}>Organization map
+ setView('impact')}>Test impact
+ setView('inventory')}>Detailed inventory
+
+
+
+
+ {liveCounts.map((count) => (
+
{count.value} {count.label}
+ ))}
+
+
+ {view === 'map' && singlePointRisks.length > 0 ? (
+
+ !
+ {singlePointRisks.length} critical coverage gap{singlePointRisks.length === 1 ? '' : 's'} found {singlePointRisks[0].eligibleMembers.map((member) => member.name).join(', ')} provide the minimum coverage for {singlePointRisks[0].requirementName} in {singlePointRisks[0].workflowName}.
+ setView('impact')}>Test this risk
+
+ ) : null}
+
+ {view === 'map' ? (
+ Opening the organization map…}> setView('inventory')} onTestImpact={() => setView('impact')} />
+ ) : view === 'impact' ? (
+ Preparing impact testing…}> setView('map')} />
+ ) : (
+ <>
+
+ moveToStage('teams')} />
+ moveToStage('members')} />
+ moveToStage('roles')} />
+ moveToStage('workflows')} />
+
+
+ {stage === 'teams' ? moveToStage('members')} /> : null}
+ {stage === 'members' ? moveToStage('roles')} /> : null}
+ {stage === 'roles' ? moveToStage('workflows')} /> : null}
+ {stage === 'workflows' ? : null}
+ >
+ )}
+
+ )
+}
+
+function StageButton({ number, label, detail, active, disabled, onClick }: {
+ number: string; label: string; detail: string; active: boolean; disabled?: boolean; onClick: () => void
+}) {
+ return (
+
+ {number} {label} {detail}
+
+ )
+}
+
+function TeamsStage({ workspaceId, catalog, onContinue }: EditorStageProps) {
+ const [editingId, setEditingId] = useState(null)
+ const [name, setName] = useState('')
+ const [department, setDepartment] = useState('')
+ const mutation = useCatalogMutation(workspaceId, (input: { name: string; department: string }) => editingId
+ ? updateDraftTeam(workspaceId, editingId, input)
+ : createDraftTeam(workspaceId, input), () => {
+ const wasCreatingFirst = !editingId && catalog.teams.length === 0
+ setName(''); setDepartment(''); setEditingId(null)
+ if (wasCreatingFirst) onContinue()
+ })
+ const deleteMutation = useCatalogMutation(workspaceId, (teamId: string) => deleteDraftTeam(workspaceId, teamId))
+
+ function submit(event: FormEvent) {
+ event.preventDefault()
+ mutation.mutate({ name: name.trim(), department: department.trim() })
+ }
+
+ return (
+
+
+
+
+ {mutation.isPending ? 'Saving…' : editingId ? 'Save team' : 'Add team'}
+ {editingId ? { setEditingId(null); setName(''); setDepartment('') }}>Cancel : null}
+
+
+ {catalog.teams.map((team) => (
+
+ {team.name} {team.department} · {team.memberCount} members
+ { setEditingId(team.id); setName(team.name); setDepartment(team.department) }}>Edit 0} title={team.memberCount > 0 ? 'Remove members first' : 'Delete team'} onClick={() => deleteMutation.mutate(team.id)}>Delete
+
+ ))}
+ {deleteMutation.isError ? {deleteMutation.error.message}
: null}
+
+
+ )
+}
+
+function MembersStage({ workspaceId, catalog, onContinue }: EditorStageProps) {
+ const [editingId, setEditingId] = useState(null)
+ const [teamId, setTeamId] = useState(catalog.teams[0]?.id ?? '')
+ const [name, setName] = useState('')
+ const [employeeNumber, setEmployeeNumber] = useState('')
+ const [email, setEmail] = useState('')
+ const [region, setRegion] = useState('NORTH_AMERICA')
+ const [shift, setShift] = useState('DAY')
+ const [selectedRoleIds, setSelectedRoleIds] = useState([])
+ const mutation = useCatalogMutation(workspaceId, async (input: Parameters[1]) => {
+ if (editingId) {
+ await updateDraftMember(workspaceId, editingId, input)
+ return replaceMemberRoles(workspaceId, editingId, selectedRoleIds)
+ }
+ const created = await createDraftMember(workspaceId, input)
+ const member = created.members.find((candidate) => !catalog.members.some((existing) => existing.id === candidate.id))
+ if (!member || selectedRoleIds.length === 0) return created
+ return replaceMemberRoles(workspaceId, member.id, selectedRoleIds)
+ }, () => {
+ const wasCreatingFirst = !editingId && catalog.members.length === 0
+ setName(''); setEmployeeNumber(''); setEmail(''); setSelectedRoleIds([]); setEditingId(null)
+ if (wasCreatingFirst) onContinue()
+ })
+ const deleteMutation = useCatalogMutation(workspaceId, (memberId: string) => deleteDraftMember(workspaceId, memberId))
+
+ function submit(event: FormEvent) {
+ event.preventDefault()
+ mutation.mutate({ teamId, employeeNumber: employeeNumber.trim() || null, name: name.trim(), email: email.trim(), status: 'ACTIVE', region, shift })
+ }
+
+ return (
+
+
+ ({ value: team.id, label: team.name }))} />
+
+
+ Use this only when matching records from an HR system. RoleImpact uses its own internal identifier.
+
+
+ setRegion(value as DraftMember['region'])} options={enumOptions(['NORTH_AMERICA', 'EUROPE', 'ASIA_PACIFIC'])} />
+ setShift(value as DraftMember['shift'])} options={enumOptions(['DAY', 'EVENING', 'NIGHT'])} />
+
+ {catalog.roles.length > 0 ? (
+
+ Assign existing roles (optional)
+ Roles are shared. The same role can be assigned to any number of members.
+ {catalog.roles.map((role) => setSelectedRoleIds((current) => event.target.checked ? [...current, role.id] : current.filter((id) => id !== role.id))} />{role.name} )}
+
+ ) : null}
+ {mutation.isPending ? 'Saving…' : editingId ? 'Save member' : 'Add member & continue'}
+ {editingId ? { setEditingId(null); setName(''); setEmployeeNumber(''); setEmail(''); setSelectedRoleIds([]) }}>Cancel : null}
+
+
+ {catalog.members.map((member) => {
+ const team = catalog.teams.find((candidate) => candidate.id === member.teamId)
+ const details = [member.employeeNumber, team?.name, `${member.roleIds.length} shared roles`].filter(Boolean).join(' · ')
+ return {member.name} {details}
{ setEditingId(member.id); setTeamId(member.teamId); setName(member.name); setEmployeeNumber(member.employeeNumber ?? ''); setEmail(member.email ?? ''); setRegion(member.region); setShift(member.shift); setSelectedRoleIds(member.roleIds) }}>Edit deleteMutation.mutate(member.id)}>Delete
+ })}
+ {deleteMutation.isError ? {deleteMutation.error.message}
: null}
+
+
+ )
+}
+
+function RolesStage({ workspaceId, catalog, onContinue }: EditorStageProps) {
+ const [editingId, setEditingId] = useState(null)
+ const [name, setName] = useState('')
+ const [description, setDescription] = useState('')
+ const [sensitivity, setSensitivity] = useState<'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL'>('MEDIUM')
+ const [ownerMemberId, setOwnerMemberId] = useState('')
+ const [selectedHolderIds, setSelectedHolderIds] = useState([])
+ const existingRole = !editingId && name.trim() ? catalog.roles.find((role) => role.name.localeCompare(name.trim(), undefined, { sensitivity: 'accent' }) === 0) : undefined
+ useEffect(() => {
+ if (existingRole) setSelectedHolderIds(catalog.members.filter((member) => member.roleIds.includes(existingRole.id)).map((member) => member.id))
+ }, [catalog.members, existingRole])
+ const mutation = useCatalogMutation(workspaceId, async (input: Parameters[1]) => {
+ if (editingId) {
+ const updated = await updateDraftRole(workspaceId, editingId, input)
+ return syncRoleHolders(workspaceId, updated, editingId, selectedHolderIds)
+ }
+ const created = await createDraftRole(workspaceId, input)
+ const role = created.roles.find((candidate) => !catalog.roles.some((existing) => existing.id === candidate.id))
+ return role ? syncRoleHolders(workspaceId, created, role.id, selectedHolderIds) : created
+ }, () => {
+ const wasCreatingFirst = !editingId && catalog.roles.length === 0
+ setName(''); setDescription(''); setOwnerMemberId(''); setSelectedHolderIds([]); setEditingId(null)
+ if (wasCreatingFirst) onContinue()
+ })
+ const reuseMutation = useCatalogMutation(workspaceId, async () => {
+ if (!existingRole) return catalog
+ return syncRoleHolders(workspaceId, catalog, existingRole.id, selectedHolderIds)
+ }, () => { setName(''); setDescription(''); setSelectedHolderIds([]) })
+ const deleteMutation = useCatalogMutation(workspaceId, (roleId: string) => deleteDraftRole(workspaceId, roleId))
+
+ function submit(event: FormEvent) {
+ event.preventDefault()
+ if (existingRole) {
+ reuseMutation.mutate(undefined)
+ return
+ }
+ mutation.mutate({ name: name.trim(), description: description.trim(), sensitivity, ownerMemberId: ownerMemberId || null })
+ }
+
+ return (
+
+
+
+ Description
+ setSensitivity(value as typeof sensitivity)} options={enumOptions(['LOW', 'MEDIUM', 'HIGH', 'CRITICAL'])} />
+ ({ value: member.id, label: member.name }))]} />
+ The administrator maintains the role. They are not automatically a role holder.
+
+ {existingRole ? {existingRole.name} is already a shared role Update its holders below instead of creating a duplicate role.
: null}
+ {mutation.isPending || reuseMutation.isPending ? 'Saving…' : existingRole ? `Update ${existingRole.name} holders` : editingId ? 'Save role and holders' : 'Add shared role & continue'}
+ {editingId ? { setEditingId(null); setName(''); setDescription(''); setOwnerMemberId(''); setSelectedHolderIds([]) }}>Cancel : null}
+
+
+
+ {catalog.roles.map((role) => {role.name} {role.sensitivity} · {role.memberCount} holders {catalog.members.filter((member) => member.roleIds.includes(role.id)).map((member) => member.name).join(', ') || 'No holders assigned'}
{ setEditingId(role.id); setName(role.name); setDescription(role.description); setSensitivity(role.sensitivity); setOwnerMemberId(role.ownerMemberId ?? ''); setSelectedHolderIds(catalog.members.filter((member) => member.roleIds.includes(role.id)).map((member) => member.id)) }}>Edit deleteMutation.mutate(role.id)}>Delete
)}
+ {deleteMutation.isError ? {deleteMutation.error.message}
: null}
+
+ {catalog.roles.length > 0 ?
: null}
+
+
+ )
+}
+
+function WorkflowsStage({ workspaceId, catalog }: EditorProps) {
+ const [targetWorkflowId, setTargetWorkflowId] = useState('new')
+ const [name, setName] = useState('')
+ const [requirementName, setRequirementName] = useState('')
+ const [criticality, setCriticality] = useState<'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL'>('HIGH')
+ const [roleId, setRoleId] = useState(catalog.roles[0]?.id ?? '')
+ const [minimumActors, setMinimumActors] = useState(1)
+ const [resilienceTarget, setResilienceTarget] = useState(1)
+ const matchingWorkflow = targetWorkflowId === 'new' && name.trim()
+ ? catalog.workflows.find((workflow) => workflow.name.toLocaleLowerCase() === name.trim().toLocaleLowerCase())
+ : undefined
+ const selectedWorkflow = catalog.workflows.find((workflow) => workflow.id === targetWorkflowId)
+ const mutation = useCatalogMutation(workspaceId, () => targetWorkflowId === 'new'
+ ? createQuickWorkflow(workspaceId, { name: name.trim(), criticality, requirementName: requirementName.trim(), roleId, minimumActors, resilienceTarget })
+ : addWorkflowRequirement(workspaceId, targetWorkflowId, { name: requirementName.trim(), roleId, minimumActors, resilienceTarget }), () => {
+ setName(''); setRequirementName(''); setMinimumActors(1); setResilienceTarget(1)
+ })
+ const deleteMutation = useCatalogMutation(workspaceId, (workflowId: string) => deleteQuickWorkflow(workspaceId, workflowId))
+
+ function submit(event: FormEvent) {
+ event.preventDefault()
+ mutation.mutate(undefined)
+ }
+
+ return (
+
+
+ workflow.quickManaged).map((workflow) => ({ value: workflow.id, label: `Add responsibility to ${workflow.name}` }))]} />
+ {targetWorkflowId === 'new' ? : null}
+ {matchingWorkflow ? {matchingWorkflow.name} already exists {matchingWorkflow.quickManaged ? 'Open it and add another role responsibility instead of duplicating the workflow.' : 'This example workflow already contains several responsibilities and is read-only in the quick editor.'}
{matchingWorkflow.quickManaged ?
{ setTargetWorkflowId(matchingWorkflow.id); setName('') }}>Add to existing workflow : null}
: null}
+ {targetWorkflowId === 'new' ? setCriticality(value as typeof criticality)} options={enumOptions(['LOW', 'MEDIUM', 'HIGH', 'CRITICAL'])} /> : null}
+
+ ({ value: role.id, label: `${role.name} · ${role.memberCount} members` }))} />
+
+ Below the minimum means blocked. Below the healthy target means degraded.
+ {mutation.isPending ? 'Saving…' : targetWorkflowId === 'new' ? 'Create workflow' : 'Add responsibility'}
+
+
+ {catalog.workflows.map((workflow) => {
+ return {workflow.name} {workflow.criticality} · {workflow.requirements.length} role responsibilities {workflow.requirements.map((requirement) => {requirement.name} · {requirement.roleIds.map((id) => catalog.roles.find((role) => role.id === id)?.name).filter(Boolean).join(' or ')} · minimum {requirement.minimumActors}, healthy {requirement.resilienceTarget} )} {workflow.quickManaged ? deleteMutation.mutate(workflow.id)}>Delete : null}
+ })}
+
+
+ )
+}
+
+function RoleAssignments({ workspaceId, catalog }: EditorProps) {
+ const mutation = useCatalogMutation(workspaceId, ({ memberId, roleIds }: { memberId: string; roleIds: string[] }) => replaceMemberRoles(workspaceId, memberId, roleIds))
+ return (
+
+ )
+}
+
+function MemberMultiSelect({ legend, members, selectedIds, onChange }: {
+ legend: string
+ members: DraftCatalog['members']
+ selectedIds: string[]
+ onChange: (ids: string[]) => void
+}) {
+ return (
+
+ {legend}
+ Select every member who should hold this shared role. There is no one-person limit.
+ {members.map((member) => (
+ onChange(event.target.checked ? [...selectedIds, member.id] : selectedIds.filter((id) => id !== member.id))} />{member.name}
+ ))}
+
+ )
+}
+
+async function syncRoleHolders(workspaceId: string, catalog: DraftCatalog, roleId: string, selectedHolderIds: string[]) {
+ const selected = new Set(selectedHolderIds)
+ let latest = catalog
+ for (const member of catalog.members) {
+ const currentlyAssigned = member.roleIds.includes(roleId)
+ const shouldBeAssigned = selected.has(member.id)
+ if (currentlyAssigned === shouldBeAssigned) continue
+ const roleIds = shouldBeAssigned ? [...member.roleIds, roleId] : member.roleIds.filter((id) => id !== roleId)
+ latest = await replaceMemberRoles(workspaceId, member.id, roleIds)
+ }
+ return latest
+}
+
+type EditorProps = { workspaceId: string; catalog: DraftCatalog }
+type EditorStageProps = EditorProps & { onContinue: () => void }
+
+function useCatalogMutation(workspaceId: string, mutationFn: (input: T) => Promise, onSuccess?: () => void) {
+ const queryClient = useQueryClient()
+ return useMutation({
+ mutationFn,
+ onSuccess: (catalog) => {
+ queryClient.setQueryData(['draft-catalog', workspaceId], catalog)
+ onSuccess?.()
+ },
+ })
+}
+
+function EditorForm({ title, intro, onSubmit, error, children }: { title: string; intro: string; onSubmit: (event: FormEvent) => void; error?: string; children: ReactNode }) {
+ return
+}
+
+function EditorList({ title, empty, children }: { title: string; empty: string; children: ReactNode }) {
+ return
{title} {Children.count(children) > 0 ? children :
{empty}
}
+}
+
+function Field({ label, value, onChange, placeholder, type = 'text' }: { label: string; value: string; onChange: (value: string) => void; placeholder: string; type?: string }) {
+ return {label} onChange(event.target.value)} />
+}
+
+function SelectField({ label, value, onChange, options }: { label: string; value: string; onChange: (value: string) => void; options: Array<{ value: string; label: string }> }) {
+ return {label} onChange(event.target.value)}>{options.map((option) => {option.label} )}
+}
+
+function NumberField({ label, value, onChange, min }: { label: string; value: number; onChange: (value: number) => void; min: number }) {
+ return {label} onChange(Math.max(min, Number(event.target.value) || min))} />
+}
+
+function enumOptions(values: string[]) {
+ return values.map((value) => ({ value, label: formatEnum(value) }))
+}
+
+function formatEnum(value: string) {
+ return value.replaceAll('_', ' ').toLowerCase().replace(/\b\w/g, (character) => character.toUpperCase())
+}
diff --git a/frontend/src/components/workspaces/editor/DraftImpactTesting.tsx b/frontend/src/components/workspaces/editor/DraftImpactTesting.tsx
new file mode 100644
index 0000000..413013b
--- /dev/null
+++ b/frontend/src/components/workspaces/editor/DraftImpactTesting.tsx
@@ -0,0 +1,202 @@
+import { lazy, Suspense, useCallback, useEffect, useMemo, useRef, useState } from 'react'
+import { useMutation } from '@tanstack/react-query'
+import { runDraftImpactPreview, type DraftImpactResult } from '../../../api/draftImpact'
+import type { DraftCatalog } from '../../../api/draftCatalog'
+import { findWorkflowRisks, type WorkflowRisk } from './workflowRisks'
+
+const WorkflowScenarioCanvas = lazy(() => import('./WorkflowScenarioCanvas'))
+
+export default function DraftImpactTesting({ workspaceId, catalog, onBackToMap }: {
+ workspaceId: string
+ catalog: DraftCatalog
+ onBackToMap: () => void
+}) {
+ const testableRisks = useMemo(
+ () => findWorkflowRisks(catalog).filter((risk) => risk.members.length > 0).toSorted((left, right) => riskRank(left) - riskRank(right)),
+ [catalog],
+ )
+ const initialRisk = testableRisks[0]
+ const [selectedWorkflowId, setSelectedWorkflowId] = useState(initialRisk?.workflowId ?? '')
+ const workflowRisks = testableRisks.filter((risk) => risk.workflowId === selectedWorkflowId)
+ const [selectedRiskKey, setSelectedRiskKey] = useState(initialRisk?.key ?? '')
+ const selectedRisk = workflowRisks.find((risk) => risk.key === selectedRiskKey) ?? workflowRisks[0]
+ const [selectedMemberId, setSelectedMemberId] = useState(selectedRisk?.members[0]?.id ?? '')
+ const [showOutcomeExplanation, setShowOutcomeExplanation] = useState(false)
+ const selectedMember = selectedRisk?.members.find((member) => member.id === selectedMemberId) ?? selectedRisk?.members[0]
+ const testableWorkflows = catalog.workflows.filter((workflow) => testableRisks.some((risk) => risk.workflowId === workflow.id))
+ const mutation = useMutation({
+ mutationFn: ({ memberId, roleId }: { memberId: string; roleId: string }) => runDraftImpactPreview(workspaceId, memberId, roleId),
+ onSuccess: () => setShowOutcomeExplanation(true),
+ })
+
+ function chooseWorkflow(workflowId: string) {
+ const firstRisk = testableRisks.find((risk) => risk.workflowId === workflowId)
+ setSelectedWorkflowId(workflowId)
+ setSelectedRiskKey(firstRisk?.key ?? '')
+ setSelectedMemberId(firstRisk?.members[0]?.id ?? '')
+ setShowOutcomeExplanation(false)
+ mutation.reset()
+ }
+
+ function chooseRisk(riskKey: string) {
+ const risk = workflowRisks.find((candidate) => candidate.key === riskKey)
+ setSelectedRiskKey(riskKey)
+ setSelectedMemberId(risk?.members[0]?.id ?? '')
+ setShowOutcomeExplanation(false)
+ mutation.reset()
+ }
+
+ function chooseScenario(riskKey: string, memberId: string) {
+ setSelectedRiskKey(riskKey)
+ setSelectedMemberId(memberId)
+ setShowOutcomeExplanation(false)
+ mutation.reset()
+ }
+
+ function runScenario(riskKey: string, memberId: string) {
+ const risk = workflowRisks.find((candidate) => candidate.key === riskKey)
+ if (!risk) return
+ setSelectedRiskKey(riskKey)
+ setSelectedMemberId(memberId)
+ mutation.mutate({ memberId, roleId: risk.roleId })
+ }
+
+ if (catalog.workflows.length === 0) {
+ return
+ }
+ if (testableRisks.length === 0) {
+ return
+ }
+
+ return (
+
+
+ Step 1
Choose a workflow Start with the business process you want to protect.
+
+ {testableWorkflows.map((workflow) => {
+ const risks = testableRisks.filter((risk) => risk.workflowId === workflow.id)
+ const outcome = workflowOutcome(risks)
+ return chooseWorkflow(workflow.id)}>{workflow.name} {workflow.requirements.length} responsibilities {outcome.label}
+ })}
+
+ Back to organization map
+
+
+
+
Drawing the current workflow…}>
+
+
+ {mutation.data && showOutcomeExplanation ?
setShowOutcomeExplanation(false)} /> : null}
+
+
+ Step 2
Choose what to test Select a responsibility and one of its role holders. You can also select nodes directly in the graph.
+ Responsibility {workflowRisks.map((risk) => chooseRisk(risk.key)}>{risk.requirementName} {risk.roleName} {predictedOutcome(risk)} )}
+ Role holder {selectedRisk.members.map((member) => { setSelectedMemberId(member.id); setShowOutcomeExplanation(false); mutation.reset() }}>{member.name} {member.eligible ? 'Eligible for this responsibility' : 'Not eligible under this responsibility’s conditions'} )}
+ {coverageHeading(selectedRisk, selectedMember.losesCoverage)} {selectedRisk.eligibleMembers.length} eligible now · minimum {selectedRisk.minimumActors} · healthy target {selectedRisk.resilienceTarget}.
+ What if {selectedMember.name} loses {selectedRisk.roleName}? No organization data will be changed.
+ runScenario(selectedRisk.key, selectedMember.id)}>{mutation.isPending ? 'Calculating impact…' : 'Run this what-if test'} {mutation.data ? { setShowOutcomeExplanation(false); mutation.reset() }}>Reset to baseline : null}
+ {mutation.isError ? {mutation.error.message}
: null}
+
+
+ {mutation.data ? : null}
+
+
+ )
+}
+
+function OutcomeExplanation({ risk, member, onDismiss }: { risk: WorkflowRisk; member: WorkflowRisk['members'][number]; onDismiss: () => void }) {
+ const timer = useRef | null>(null)
+ const survivors = risk.eligibleMembers.filter((candidate) => candidate.id !== member.id || !member.losesCoverage)
+ const tone = survivors.length < risk.minimumActors ? 'blocked' : survivors.length < risk.resilienceTarget ? 'degraded' : 'safe'
+ const heading = tone === 'blocked' ? 'This responsibility is now blocked' : tone === 'degraded' ? 'It still works, but resilience is reduced' : 'Coverage remains healthy'
+ const coverageText = survivors.length === 0
+ ? `${member.name} was the only eligible holder. No one can now perform ${risk.requirementName}.`
+ : `${member.name} loses ${risk.roleName}, but ${formatNames(survivors.map((survivor) => survivor.name))} ${survivors.length === 1 ? 'still provides' : 'still provide'} coverage.`
+
+ const scheduleDismiss = useCallback(() => {
+ if (timer.current) window.clearTimeout(timer.current)
+ timer.current = window.setTimeout(onDismiss, 8000)
+ }, [onDismiss])
+ useEffect(() => {
+ scheduleDismiss()
+ return () => { if (timer.current) window.clearTimeout(timer.current) }
+ }, [scheduleDismiss])
+
+ return (
+ { if (timer.current) window.clearTimeout(timer.current) }} onMouseLeave={scheduleDismiss}>
+ {tone === 'blocked' ? '!' : tone === 'degraded' ? '△' : '✓'}
+ {heading} {coverageText}
Rule: {survivors.length} eligible after change · minimum {risk.minimumActors} to operate · {risk.resilienceTarget} for healthy coverage.
+ ×
+
+ )
+}
+
+function formatNames(names: string[]) {
+ if (names.length <= 1) return names[0] ?? 'no one'
+ if (names.length === 2) return `${names[0]} and ${names[1]}`
+ return `${names.slice(0, -1).join(', ')}, and ${names.at(-1)}`
+}
+
+function ImpactResultSummary({ result, requirementName }: { result: DraftImpactResult; requirementName: string }) {
+ return (
+
+ Preview result · {requirementName}
{resultHeading(result)} {resultExplanation(result, requirementName)}
{result.overallSeverity}
+ {result.executiveSummary.workflowsBlocked} blocked {result.executiveSummary.workflowsDegraded} degraded {result.executiveSummary.permissionsLost} permissions lost
+
+ )
+}
+
+function EmptyImpact({ title, message, action, onAction, warning = false }: { title: string; message: string; action: string; onAction: () => void; warning?: boolean }) {
+ return {warning ? '!' : '◎'} Impact testing
{title} {message}
{action}
+}
+
+function resultHeading(result: DraftImpactResult) {
+ if (result.executiveSummary.workflowsBlocked > 0) return 'A workflow would be blocked'
+ if (result.executiveSummary.workflowsDegraded > 0) return 'Resilience would be reduced'
+ return 'The workflow remains operational'
+}
+
+function resultExplanation(result: DraftImpactResult, requirementName: string) {
+ const change = result.changeSet
+ return `If ${change.employee.name} loses ${change.role.name}, RoleImpact recalculates ${requirementName}: ${result.executiveSummary.workflowsBlocked} workflow(s) are blocked and ${result.executiveSummary.workflowsDegraded} are degraded.`
+}
+
+function workflowOutcome(risks: WorkflowRisk[]) {
+ const best = risks.toSorted((left, right) => riskRank(left) - riskRank(right))[0]
+ return best ? { label: predictedOutcome(best), tone: outcomeTone(best) } : { label: 'not testable', tone: 'neutral' }
+}
+
+function riskRank(risk: WorkflowRisk) {
+ const remaining = remainingCoverage(risk)
+ if (remaining < risk.minimumActors) return 0
+ if (remaining < risk.resilienceTarget) return 1
+ return 2
+}
+
+function predictedOutcome(risk: WorkflowRisk) {
+ const remaining = remainingCoverage(risk)
+ if (remaining < risk.minimumActors) return 'would block'
+ if (remaining < risk.resilienceTarget) return 'would degrade'
+ return 'coverage remains safe'
+}
+
+function outcomeTone(risk: WorkflowRisk) {
+ return ['danger', 'warning', 'safe'][riskRank(risk)]
+}
+
+function remainingCoverage(risk: WorkflowRisk) {
+ return risk.eligibleMembers.length - (risk.members.some((member) => member.losesCoverage) ? 1 : 0)
+}
+
+function coverageHeading(risk: WorkflowRisk, losesCoverage: boolean) {
+ if (!losesCoverage) return 'Other access still covers this step'
+ const remaining = risk.eligibleMembers.length - 1
+ if (remaining < risk.minimumActors) return 'This change would block the step'
+ if (remaining < risk.resilienceTarget) return 'This change would reduce resilience'
+ return 'Coverage would remain healthy'
+}
+
+function coverageTone(risk: WorkflowRisk, losesCoverage: boolean) {
+ if (!losesCoverage) return 'ready'
+ return risk.eligibleMembers.length - 1 < risk.resilienceTarget ? 'critical' : 'ready'
+}
diff --git a/frontend/src/components/workspaces/editor/OrganizationCanvas.tsx b/frontend/src/components/workspaces/editor/OrganizationCanvas.tsx
new file mode 100644
index 0000000..2c317d5
--- /dev/null
+++ b/frontend/src/components/workspaces/editor/OrganizationCanvas.tsx
@@ -0,0 +1,837 @@
+import { useEffect, useMemo, useState, type DragEvent, type FormEvent } from 'react'
+import { useMutation, useQueryClient } from '@tanstack/react-query'
+import {
+ Background,
+ Controls,
+ Handle,
+ MarkerType,
+ Position,
+ ReactFlow,
+ ReactFlowProvider,
+ useNodesState,
+ useReactFlow,
+ type Connection,
+ type Edge,
+ type Node,
+ type NodeProps,
+ type XYPosition,
+} from '@xyflow/react'
+import '@xyflow/react/dist/style.css'
+import {
+ addWorkflowRequirement,
+ createDraftMember,
+ createDraftRole,
+ createDraftTeam,
+ createQuickWorkflow,
+ deleteDraftMember,
+ deleteDraftRole,
+ deleteDraftTeam,
+ deleteQuickWorkflow,
+ replaceMemberRoles,
+ updateDraftMember,
+ type DraftCatalog,
+ type DraftMember,
+} from '../../../api/draftCatalog'
+
+type EntityType = 'team' | 'member' | 'role' | 'workflow'
+type GraphEntityType = EntityType | 'responsibility'
+type CanvasNodeData = { label: string; entityType: GraphEntityType; detail: string; emphasis?: 'highlighted' | 'dimmed' }
+type CanvasNode = Node
+type PendingCreate = { entityType: EntityType; position?: XYPosition }
+type QuickCreateOptions = {
+ department: string
+ sensitivity: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL'
+ criticality: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL'
+}
+
+const nodeTypes = { organization: OrganizationNode }
+const entityTypes: EntityType[] = ['team', 'member', 'role', 'workflow']
+const graphEntityTypes: GraphEntityType[] = ['team', 'member', 'role', 'responsibility', 'workflow']
+const typeLabels: Record = {
+ team: 'Team',
+ member: 'Member',
+ role: 'Role',
+ workflow: 'Workflow',
+ responsibility: 'Responsibility',
+}
+
+export default function OrganizationCanvas(props: {
+ workspaceId: string
+ catalog: DraftCatalog
+ initialFocus: boolean
+ onOpenInventory: () => void
+ onTestImpact: () => void
+}) {
+ return (
+
+
+
+ )
+}
+
+function OrganizationCanvasInner({ workspaceId, catalog, initialFocus, onOpenInventory, onTestImpact }: {
+ workspaceId: string
+ catalog: DraftCatalog
+ initialFocus: boolean
+ onOpenInventory: () => void
+ onTestImpact: () => void
+}) {
+ const queryClient = useQueryClient()
+ const { screenToFlowPosition, fitView } = useReactFlow()
+ const [nodes, setNodes, onNodesChange] = useNodesState(buildNodes(catalog, workspaceId))
+ const [layoutMode, setLayoutMode] = useState<'automatic' | 'manual'>(() => Object.keys(readPositions(workspaceId)).length > 0 ? 'manual' : 'automatic')
+ const [selectedNodeId, setSelectedNodeId] = useState(null)
+ const [pendingCreate, setPendingCreate] = useState(null)
+ const [search, setSearch] = useState('')
+ const [inventoryType, setInventoryType] = useState('all')
+ const [notice, setNotice] = useState(null)
+ const [scope, setScope] = useState<'focus' | 'full'>(initialFocus && catalog.workflows.length > 0 ? 'focus' : 'full')
+ const [focusedWorkflowId, setFocusedWorkflowId] = useState(catalog.workflows[0]?.id ?? '')
+ const [pendingDelete, setPendingDelete] = useState(null)
+
+ useEffect(() => {
+ setNodes((currentNodes) => layoutMode === 'automatic'
+ ? buildNodes(catalog, workspaceId, false)
+ : mergeCatalogNodes(currentNodes, catalog, workspaceId))
+ if (layoutMode === 'automatic') window.requestAnimationFrame(() => void fitView({ duration: 300, padding: 0.25 }))
+ }, [catalog, fitView, layoutMode, setNodes, workspaceId])
+
+ useEffect(() => {
+ if (catalog.workflows.length === 0) {
+ setFocusedWorkflowId('')
+ setScope('full')
+ }
+ else if (!catalog.workflows.some((workflow) => workflow.id === focusedWorkflowId)) {
+ setFocusedWorkflowId(catalog.workflows[0].id)
+ }
+ }, [catalog.workflows, focusedWorkflowId])
+
+ useEffect(() => {
+ window.requestAnimationFrame(() => void fitView({ duration: 300, padding: 0.28 }))
+ }, [fitView, focusedWorkflowId, scope])
+
+ const pathIds = useMemo(() => selectedNodeId ? relatedPathIds(catalog, selectedNodeId) : null, [catalog, selectedNodeId])
+ const edges = useMemo(() => emphasizeEdges(buildEdges(catalog), pathIds), [catalog, pathIds])
+ const focusIds = useMemo(() => focusedNodeIds(catalog, focusedWorkflowId), [catalog, focusedWorkflowId])
+ const emphasizedNodes = useMemo(() => nodes.map((node) => ({ ...node, data: { ...node.data, emphasis: pathIds ? pathIds.has(node.id) ? 'highlighted' as const : 'dimmed' as const : undefined } })), [nodes, pathIds])
+ const visibleNodes = scope === 'full' ? emphasizedNodes : compactFocusedNodes(emphasizedNodes, focusIds)
+ const visibleEdges = scope === 'full' ? edges : edges.filter((edge) => focusIds.has(edge.source) && focusIds.has(edge.target))
+ const selectedNode = nodes.find((node) => node.id === selectedNodeId)
+ const inventoryNodes = nodes.filter((node) => {
+ const matchesType = inventoryType === 'all' || node.data.entityType === inventoryType
+ return matchesType && node.data.label.toLowerCase().includes(search.trim().toLowerCase())
+ })
+
+ const connectionMutation = useMutation({
+ mutationFn: async (connection: Connection) => connectEntities(workspaceId, catalog, connection),
+ onSuccess: (nextCatalog) => {
+ queryClient.setQueryData(['draft-catalog', workspaceId], nextCatalog)
+ setNotice('Relationship saved')
+ },
+ onError: (error: Error) => setNotice(error.message),
+ })
+ const deleteMutation = useMutation({
+ mutationFn: (node: CanvasNode) => deleteEntity(workspaceId, node, catalog),
+ onSuccess: (nextCatalog, node) => {
+ queryClient.setQueryData(['draft-catalog', workspaceId], nextCatalog)
+ removeSavedPosition(workspaceId, node.id)
+ setSelectedNodeId(null)
+ setPendingDelete(null)
+ setNotice(`${typeLabels[node.data.entityType]} deleted`)
+ },
+ onError: (error: Error) => setNotice(error.message),
+ })
+
+ function beginCreate(entityType: EntityType, position?: XYPosition) {
+ const prerequisite = prerequisiteMessage(entityType, catalog)
+ if (prerequisite) {
+ setNotice(prerequisite)
+ return
+ }
+ setNotice(null)
+ setPendingCreate({ entityType, position })
+ }
+
+ function dropEntity(event: DragEvent) {
+ event.preventDefault()
+ const entityType = event.dataTransfer.getData('application/roleimpact-node') as EntityType
+ if (!entityTypes.includes(entityType)) return
+ beginCreate(entityType, screenToFlowPosition({ x: event.clientX, y: event.clientY }))
+ }
+
+ function savePosition(node: CanvasNode) {
+ setLayoutMode('manual')
+ const positions = readPositions(workspaceId)
+ positions[node.id] = node.position
+ localStorage.setItem(positionKey(workspaceId), JSON.stringify(positions))
+ }
+
+ function autoArrange() {
+ localStorage.removeItem(positionKey(workspaceId))
+ setLayoutMode('automatic')
+ setNodes(buildNodes(catalog, workspaceId, false))
+ window.requestAnimationFrame(() => void fitView({ duration: 350, padding: 0.25 }))
+ }
+
+ function focusNode(nodeId: string) {
+ if (!focusIds.has(nodeId)) setScope('full')
+ setSelectedNodeId(nodeId)
+ const target = nodes.find((node) => node.id === nodeId)
+ if (target) window.requestAnimationFrame(() => void fitView({ nodes: [target], duration: 350, maxZoom: 1.05, padding: 1.5 }))
+ }
+
+ return (
+
+
+
+
Objects
+
Drag onto canvas
+
Drop an object, give it a name, and connect it to the next layer.
+
+
+ {entityTypes.map((entityType) => {
+ const blocked = Boolean(prerequisiteMessage(entityType, catalog))
+ return (
+ {
+ event.dataTransfer.setData('application/roleimpact-node', entityType)
+ event.dataTransfer.effectAllowed = 'copy'
+ }}
+ onClick={() => beginCreate(entityType)}
+ >
+ {entityIcon(entityType)}
+ {typeLabels[entityType]}
+ {paletteDetail(entityType)}
+
+ )
+ })}
+
+
+ Connect in this order
+ Team → Member → Role → Responsibility → Workflow
+
+
+
+
+
+
Organization map {scope === 'focus' ? `${visibleNodes.length} of ${nodes.length} objects in focus` : `${nodes.length} objects · ${edges.length} connections`}
+
+ {catalog.workflows.length > 0 ? Focused workflow { setFocusedWorkflowId(event.target.value); setScope('focus') }}>{catalog.workflows.map((workflow) => {workflow.name} )} : null}
+ {catalog.workflows.length > 0 ? setScope(scope === 'focus' ? 'full' : 'focus')}>{scope === 'focus' ? 'Show full map' : 'Focus workflow'} : null}
+ {scope === 'full' ? Re-arrange graph : null}
+ void fitView({ duration: 350, padding: 0.25 })}>Fit graph
+
+
+ { event.preventDefault(); event.dataTransfer.dropEffect = 'copy' }}
+ onDrop={dropEntity}
+ >
+
+ nodes={visibleNodes}
+ edges={visibleEdges}
+ nodeTypes={nodeTypes}
+ onNodesChange={onNodesChange}
+ nodesDraggable={scope === 'full'}
+ onNodeDragStop={(_, node) => { if (scope === 'full') savePosition(node) }}
+ onNodeClick={(_, node) => setSelectedNodeId(node.id)}
+ onConnect={(connection) => connectionMutation.mutate(connection)}
+ isValidConnection={(connection) => isValidConnection(connection, catalog)}
+ fitView
+ fitViewOptions={{ padding: 0.28, minZoom: 0.55, maxZoom: 1 }}
+ minZoom={0.35}
+ maxZoom={1.4}
+ deleteKeyCode={null}
+ >
+
+
+
+ {nodes.length === 0 ? (
+
+
+
+
Start with a team
+
Drag a Team here or select it from the object tray.
+
beginCreate('team')}>Create first team
+
+ ) : null}
+
+ {notice ? {notice} setNotice(null)}>×
: null}
+
+
+
+
+ Search inventory setSearch(event.target.value)} />
+
+ {(['all', ...graphEntityTypes] as const).map((entityType) => (
+ setInventoryType(entityType)}>{entityType === 'all' ? 'All' : typeLabels[entityType]}
+ ))}
+
+
+ {inventoryNodes.map((node) => (
+
focusNode(node.id)}>
+ {entityIcon(node.data.entityType)}
+ {node.data.label} {node.data.detail}
+
+ ))}
+ {inventoryNodes.length === 0 ?
No matching objects.
: null}
+
+ {selectedNode ? (
+
+
{typeLabels[selectedNode.data.entityType]}
+
{selectedNode.data.label}
+
{selectedNode.data.detail}
+
+ {(selectedNode.data.entityType === 'member' || selectedNode.data.entityType === 'role') ? Test impact : null}
+ {selectedNode.data.entityType !== 'responsibility' ? { deleteMutation.reset(); setPendingDelete(selectedNode) }}>Delete object : null}
+
+
+ ) : null}
+
+
+ {pendingCreate ? (
+
setPendingCreate(null)}
+ onCreated={(nextCatalog, createdId, successMessage) => {
+ if (layoutMode === 'manual') {
+ const positions = readPositions(workspaceId)
+ positions[createdId] = nextOpenPosition(pendingCreate.entityType, nodes, pendingCreate.position)
+ localStorage.setItem(positionKey(workspaceId), JSON.stringify(positions))
+ }
+ queryClient.setQueryData(['draft-catalog', workspaceId], nextCatalog)
+ setSelectedNodeId(createdId)
+ setPendingCreate(null)
+ setNotice(successMessage ?? `${typeLabels[pendingCreate.entityType]} created`)
+ }}
+ />
+ ) : null}
+ {pendingDelete ? (
+ setPendingDelete(null)}
+ onConfirm={() => deleteMutation.mutate(pendingDelete)}
+ />
+ ) : null}
+
+ )
+}
+
+function QuickCreate({ workspaceId, catalog, pending, onCancel, onCreated }: {
+ workspaceId: string
+ catalog: DraftCatalog
+ pending: PendingCreate
+ onCancel: () => void
+ onCreated: (catalog: DraftCatalog, nodeId: string, successMessage?: string) => void
+}) {
+ const [name, setName] = useState('')
+ const [parentId, setParentId] = useState(defaultParentId(pending.entityType, catalog))
+ const [selectedMemberIds, setSelectedMemberIds] = useState([])
+ const [memberSearch, setMemberSearch] = useState('')
+ const [department, setDepartment] = useState('General')
+ const [sensitivity, setSensitivity] = useState('MEDIUM')
+ const [criticality, setCriticality] = useState('HIGH')
+ const mutation = useMutation({
+ mutationFn: async () => createEntity(workspaceId, pending.entityType, name.trim(), parentId, catalog, selectedMemberIds, { department, sensitivity, criticality }),
+ onSuccess: ({ catalog: nextCatalog, nodeId }) => {
+ const reused = findExistingEntity(pending.entityType, name, catalog)
+ const successMessage = reused ? pending.entityType === 'role' ? 'Role assigned' : 'Workflow updated' : undefined
+ onCreated(nextCatalog, nodeId, successMessage)
+ },
+ })
+
+ function submit(event: FormEvent) {
+ event.preventDefault()
+ mutation.mutate()
+ }
+
+ const relationshipOptions = parentOptions(pending.entityType, catalog)
+ const existingEntity = findExistingEntity(pending.entityType, name, catalog)
+ const roleAlreadyRequired = pending.entityType === 'workflow' && existingEntity && 'requirements' in existingEntity
+ ? existingEntity.requirements.some((requirement) => requirement.roleIds.includes(parentId))
+ : false
+ const cannotReuse = pending.entityType === 'workflow' && existingEntity && (!('quickManaged' in existingEntity && existingEntity.quickManaged) || roleAlreadyRequired)
+ const visibleMembers = catalog.members.filter((member) => member.name.toLowerCase().includes(memberSearch.trim().toLowerCase()))
+ return (
+ { if (event.target === event.currentTarget) onCancel() }}>
+
+
+ )
+}
+
+function DeleteConfirmation({ node, catalog, isPending, error, onCancel, onConfirm }: {
+ node: CanvasNode
+ catalog: DraftCatalog
+ isPending: boolean
+ error?: string
+ onCancel: () => void
+ onConfirm: () => void
+}) {
+ const impact = deletionImpact(node, catalog)
+ return (
+ { if (event.target === event.currentTarget) onCancel() }}>
+
+ ×
+ Delete {typeLabels[node.data.entityType]}
Remove {node.data.label}? {impact.message}
+ {impact.dependencies.length > 0 ? {impact.dependencies.map((dependency) => {dependency} )} : null}
+ {error ? {error}
: null}
+ Cancel {isPending ? 'Deleting…' : impact.blocked ? 'Resolve dependencies first' : 'Delete object'}
+
+
+ )
+}
+
+function OrganizationNode({ data, selected }: NodeProps) {
+ return (
+
+
+ {entityIcon(data.entityType)}
+ {typeLabels[data.entityType]} {data.label} {data.detail}
+
+
+ )
+}
+
+function buildNodes(catalog: DraftCatalog, workspaceId: string, useSavedPositions = true): CanvasNode[] {
+ const automatic = automaticPositions(catalog)
+ const saved = useSavedPositions ? readPositions(workspaceId) : {}
+ const items: Array<{ id: string; label: string; detail: string; entityType: GraphEntityType }> = [
+ ...catalog.teams.map((team) => ({ id: nodeId('team', team.id), label: team.name, detail: team.department || 'General', entityType: 'team' as const })),
+ ...catalog.members.map((member) => ({
+ id: nodeId('member', member.id),
+ label: member.name,
+ detail: [catalog.teams.find((team) => team.id === member.teamId)?.name ?? 'No primary team', member.employeeNumber].filter(Boolean).join(' · '),
+ entityType: 'member' as const,
+ })),
+ ...catalog.roles.map((role) => ({ id: nodeId('role', role.id), label: role.name, detail: `${role.sensitivity.toLowerCase()} sensitivity`, entityType: 'role' as const })),
+ ...catalog.workflows.flatMap((workflow) => workflow.requirements.map((requirement) => ({
+ id: nodeId('responsibility', requirement.id),
+ label: requirement.name,
+ detail: `minimum ${requirement.minimumActors} · resilience ${requirement.resilienceTarget}`,
+ entityType: 'responsibility' as const,
+ }))),
+ ...catalog.workflows.map((workflow) => ({ id: nodeId('workflow', workflow.id), label: workflow.name, detail: `${workflow.criticality.toLowerCase()} criticality`, entityType: 'workflow' as const })),
+ ]
+ return items.map((item) => ({
+ id: item.id,
+ type: 'organization' as const,
+ position: saved[item.id] ?? automatic[item.id] ?? { x: 50, y: 60 },
+ data: { label: item.label, entityType: item.entityType, detail: item.detail },
+ ariaLabel: `${typeLabels[item.entityType]} ${item.label}`,
+ }))
+}
+
+function compactFocusedNodes(nodes: CanvasNode[], focusIds: Set) {
+ const focused = nodes.filter((node) => focusIds.has(node.id))
+ const minimumX = Math.min(...focused.map((node) => node.position.x), 50)
+ const minimumY = Math.min(...focused.map((node) => node.position.y), 60)
+ return focused.map((node) => ({ ...node, position: { x: node.position.x - minimumX + 50, y: node.position.y - minimumY + 60 } }))
+}
+
+function mergeCatalogNodes(current: CanvasNode[], catalog: DraftCatalog, workspaceId: string) {
+ const rebuilt = buildNodes(catalog, workspaceId)
+ const currentPositions = new Map(current.map((node) => [node.id, node.position]))
+ return rebuilt.map((node) => ({ ...node, position: currentPositions.get(node.id) ?? node.position }))
+}
+
+function buildEdges(catalog: DraftCatalog): Edge[] {
+ const edges: Edge[] = []
+ catalog.members.forEach((member) => {
+ edges.push(graphEdge(`team-member-${member.id}`, nodeId('team', member.teamId), nodeId('member', member.id), 'contains'))
+ member.roleIds.forEach((roleId) => edges.push(graphEdge(`member-role-${member.id}-${roleId}`, nodeId('member', member.id), nodeId('role', roleId), 'assigned')))
+ })
+ catalog.workflows.forEach((workflow) => {
+ workflow.requirements.forEach((requirement) => requirement.roleIds.forEach((roleId) => {
+ edges.push(graphEdge(`role-responsibility-${requirement.id}-${roleId}`, nodeId('role', roleId), nodeId('responsibility', requirement.id), 'can perform'))
+ }))
+ workflow.requirements.forEach((requirement) => edges.push(graphEdge(`responsibility-workflow-${workflow.id}-${requirement.id}`, nodeId('responsibility', requirement.id), nodeId('workflow', workflow.id), 'supports')))
+ })
+ return edges
+}
+
+function automaticPositions(catalog: DraftCatalog): Record {
+ const positions: Record = {}
+ const responsibilities = catalog.workflows.flatMap((workflow, workflowIndex) => workflow.requirements
+ .slice()
+ .sort((left, right) => left.position - right.position)
+ .map((requirement) => ({ workflow, workflowIndex, requirement })))
+ const responsibilityRank = new Map(responsibilities.map((item, index) => [item.requirement.id, index]))
+ const roleRank = (roleId: string) => {
+ const matches = responsibilities.filter((item) => item.requirement.roleIds.includes(roleId)).map((item) => responsibilityRank.get(item.requirement.id) ?? Number.MAX_SAFE_INTEGER)
+ return matches.length > 0 ? Math.min(...matches) : Number.MAX_SAFE_INTEGER
+ }
+ const orderedRoles = catalog.roles.slice().sort((left, right) => roleRank(left.id) - roleRank(right.id) || left.name.localeCompare(right.name))
+ const roleOrder = new Map(orderedRoles.map((role, index) => [role.id, index]))
+ const primaryRole = (member: DraftMember) => member.roleIds.slice().sort((left, right) => (roleOrder.get(left) ?? Number.MAX_SAFE_INTEGER) - (roleOrder.get(right) ?? Number.MAX_SAFE_INTEGER))[0]
+ const placedMembers = new Set()
+ const roleY = new Map()
+ let cursorY = 60
+
+ orderedRoles.forEach((role) => {
+ const members = catalog.members.filter((member) => primaryRole(member) === role.id)
+ const rowCount = Math.max(1, members.length)
+ members.forEach((member, index) => {
+ positions[nodeId('member', member.id)] = { x: 350, y: cursorY + index * 115 }
+ placedMembers.add(member.id)
+ })
+ const centerY = cursorY + ((rowCount - 1) * 115) / 2
+ positions[nodeId('role', role.id)] = { x: 650, y: centerY }
+ roleY.set(role.id, centerY)
+ cursorY += rowCount * 115 + 45
+ })
+
+ catalog.members.filter((member) => !placedMembers.has(member.id)).forEach((member) => {
+ positions[nodeId('member', member.id)] = { x: 350, y: cursorY }
+ cursorY += 115
+ })
+
+ let responsibilityFloor = 60
+ responsibilities.forEach(({ requirement }) => {
+ const linkedY = requirement.roleIds.map((roleId) => roleY.get(roleId)).filter((value): value is number => value !== undefined)
+ const desiredY = linkedY.length > 0 ? linkedY.reduce((sum, value) => sum + value, 0) / linkedY.length : responsibilityFloor
+ const y = Math.max(desiredY, responsibilityFloor)
+ positions[nodeId('responsibility', requirement.id)] = { x: 950, y }
+ responsibilityFloor = y + 115
+ })
+
+ let workflowFloor = 60
+ catalog.workflows.forEach((workflow) => {
+ const linkedY = workflow.requirements.map((requirement) => positions[nodeId('responsibility', requirement.id)]?.y).filter((value): value is number => value !== undefined)
+ const desiredY = linkedY.length > 0 ? linkedY.reduce((sum, value) => sum + value, 0) / linkedY.length : workflowFloor
+ const y = Math.max(desiredY, workflowFloor)
+ positions[nodeId('workflow', workflow.id)] = { x: 1250, y }
+ workflowFloor = y + 135
+ })
+
+ const desiredTeams = catalog.teams.map((team) => {
+ const linkedY = catalog.members.filter((member) => member.teamId === team.id).map((member) => positions[nodeId('member', member.id)]?.y).filter((value): value is number => value !== undefined)
+ return { team, desiredY: linkedY.length > 0 ? linkedY.reduce((sum, value) => sum + value, 0) / linkedY.length : cursorY }
+ }).sort((left, right) => left.desiredY - right.desiredY)
+ let teamFloor = 60
+ desiredTeams.forEach(({ team, desiredY }) => {
+ const y = Math.max(desiredY, teamFloor)
+ positions[nodeId('team', team.id)] = { x: 50, y }
+ teamFloor = y + 115
+ })
+ return positions
+}
+
+function graphEdge(id: string, source: string, target: string, label: string): Edge {
+ return {
+ id, source, target, label, type: 'smoothstep',
+ style: { stroke: '#7f6ce5', strokeWidth: 1.8 },
+ labelStyle: { fill: '#aeb5c7', fontSize: 9, fontWeight: 700 },
+ labelBgStyle: { fill: '#12151e', fillOpacity: 0.95 },
+ markerEnd: { type: MarkerType.ArrowClosed, color: '#7f6ce5', width: 16, height: 16 },
+ }
+}
+
+function emphasizeEdges(edges: Edge[], pathIds: Set | null) {
+ if (!pathIds) return edges
+ return edges.map((edge) => {
+ const highlighted = pathIds.has(edge.source) && pathIds.has(edge.target)
+ return {
+ ...edge,
+ animated: highlighted,
+ style: { ...edge.style, opacity: highlighted ? 1 : 0.12, strokeWidth: highlighted ? 2.4 : 1.2 },
+ labelStyle: { ...edge.labelStyle, opacity: highlighted ? 1 : 0.08 },
+ }
+ })
+}
+
+function relatedPathIds(catalog: DraftCatalog, selectedNodeId: string) {
+ const selected = parseNodeId(selectedNodeId)
+ const ids = new Set([selectedNodeId])
+ const addRolePath = (roleId: string) => {
+ ids.add(nodeId('role', roleId))
+ catalog.members.filter((member) => member.roleIds.includes(roleId)).forEach((member) => {
+ ids.add(nodeId('member', member.id))
+ ids.add(nodeId('team', member.teamId))
+ })
+ catalog.workflows.forEach((workflow) => workflow.requirements.filter((requirement) => requirement.roleIds.includes(roleId)).forEach((requirement) => {
+ ids.add(nodeId('responsibility', requirement.id))
+ ids.add(nodeId('workflow', workflow.id))
+ }))
+ }
+ if (selected.type === 'member') {
+ const member = catalog.members.find((candidate) => candidate.id === selected.id)
+ if (member) {
+ ids.add(nodeId('team', member.teamId))
+ member.roleIds.forEach(addRolePath)
+ }
+ } else if (selected.type === 'role') {
+ addRolePath(selected.id)
+ } else if (selected.type === 'responsibility') {
+ catalog.workflows.forEach((workflow) => workflow.requirements.filter((requirement) => requirement.id === selected.id).forEach((requirement) => {
+ ids.add(nodeId('workflow', workflow.id))
+ requirement.roleIds.forEach(addRolePath)
+ }))
+ } else if (selected.type === 'workflow') {
+ const workflow = catalog.workflows.find((candidate) => candidate.id === selected.id)
+ workflow?.requirements.forEach((requirement) => {
+ ids.add(nodeId('responsibility', requirement.id))
+ requirement.roleIds.forEach(addRolePath)
+ })
+ } else if (selected.type === 'team') {
+ catalog.members.filter((member) => member.teamId === selected.id).forEach((member) => {
+ ids.add(nodeId('member', member.id))
+ member.roleIds.forEach(addRolePath)
+ })
+ }
+ return ids
+}
+
+async function deleteEntity(workspaceId: string, node: CanvasNode, catalog: DraftCatalog) {
+ const entity = parseNodeId(node.id)
+ if (entity.type === 'responsibility') throw new Error('Responsibilities are edited as part of their workflow.')
+ const impact = deletionImpact(node, catalog)
+ if (impact.blocked) throw new Error(impact.message)
+ if (entity.type === 'team') return deleteDraftTeam(workspaceId, entity.id)
+ if (entity.type === 'member') return deleteDraftMember(workspaceId, entity.id)
+ if (entity.type === 'role') return deleteDraftRole(workspaceId, entity.id)
+ return deleteQuickWorkflow(workspaceId, entity.id)
+}
+
+function deletionImpact(node: CanvasNode, catalog: DraftCatalog) {
+ const entity = parseNodeId(node.id)
+ if (entity.type === 'responsibility') return { blocked: true, message: 'Responsibilities are edited as part of their workflow.', dependencies: [] as string[] }
+ if (entity.type === 'team') {
+ const members = catalog.members.filter((member) => member.teamId === entity.id)
+ return {
+ blocked: members.length > 0,
+ message: members.length > 0 ? 'This team still contains members. Move or delete them before deleting the team.' : 'The team will be removed from the organization map.',
+ dependencies: members.map((member) => `Member: ${member.name}`),
+ }
+ }
+ if (entity.type === 'member') {
+ const member = catalog.members.find((candidate) => candidate.id === entity.id)
+ const roles = catalog.roles.filter((role) => member?.roleIds.includes(role.id))
+ return { blocked: false, message: 'The member and all of their role assignments will be removed from the baseline.', dependencies: roles.map((role) => `Role assignment: ${role.name}`) }
+ }
+ if (entity.type === 'role') {
+ const workflows = catalog.workflows.filter((workflow) => workflow.requirements.some((requirement) => requirement.roleIds.includes(entity.id)))
+ return {
+ blocked: workflows.length > 0,
+ message: workflows.length > 0 ? 'This role enables business workflows. Delete those workflows first so the baseline cannot become incomplete.' : 'The role and its member assignments will be removed.',
+ dependencies: workflows.map((workflow) => `Workflow: ${workflow.name}`),
+ }
+ }
+ return { blocked: false, message: 'The workflow and its generated dependency chain will be removed from the baseline.', dependencies: [] as string[] }
+}
+
+function focusedNodeIds(catalog: DraftCatalog, workflowId: string) {
+ const ids = new Set()
+ const workflow = catalog.workflows.find((candidate) => candidate.id === workflowId)
+ if (!workflow) return ids
+ ids.add(nodeId('workflow', workflow.id))
+ workflow.requirements.forEach((requirement) => ids.add(nodeId('responsibility', requirement.id)))
+ const roleIds = new Set(workflow.requirements.flatMap((requirement) => requirement.roleIds))
+ roleIds.forEach((roleId) => ids.add(nodeId('role', roleId)))
+ catalog.members.filter((member) => member.roleIds.some((roleId) => roleIds.has(roleId))).forEach((member) => {
+ ids.add(nodeId('member', member.id))
+ ids.add(nodeId('team', member.teamId))
+ })
+ return ids
+}
+
+async function createEntity(workspaceId: string, entityType: EntityType, name: string, parentId: string, catalog: DraftCatalog, selectedMemberIds: string[] = [], options: QuickCreateOptions = { department: 'General', sensitivity: 'MEDIUM', criticality: 'HIGH' }) {
+ if (entityType === 'team') {
+ const next = await createDraftTeam(workspaceId, { name, department: options.department.trim() || 'General' })
+ return { catalog: next, nodeId: nodeId('team', findCreatedId(catalog.teams, next.teams)) }
+ }
+ if (entityType === 'member') {
+ const next = await createDraftMember(workspaceId, { teamId: parentId, employeeNumber: null, name, email: '', status: 'ACTIVE', region: 'NORTH_AMERICA', shift: 'DAY' })
+ return { catalog: next, nodeId: nodeId('member', findCreatedId(catalog.members, next.members)) }
+ }
+ if (entityType === 'role') {
+ const existingRole = catalog.roles.find((role) => normalizedName(role.name) === normalizedName(name))
+ if (existingRole) {
+ const next = await assignRoleToMembers(workspaceId, catalog, existingRole.id, selectedMemberIds)
+ return { catalog: next, nodeId: nodeId('role', existingRole.id) }
+ }
+ const created = await createDraftRole(workspaceId, { name, description: `${name} responsibilities`, sensitivity: options.sensitivity, ownerMemberId: null })
+ const roleId = findCreatedId(catalog.roles, created.roles)
+ const next = await assignRoleToMembers(workspaceId, created, roleId, selectedMemberIds)
+ return { catalog: next, nodeId: nodeId('role', roleId) }
+ }
+ const existingWorkflow = catalog.workflows.find((workflow) => normalizedName(workflow.name) === normalizedName(name))
+ const role = catalog.roles.find((candidate) => candidate.id === parentId)
+ const requirementName = `${role?.name ?? 'Required role'} responsibility`
+ if (existingWorkflow) {
+ if (!existingWorkflow.quickManaged) throw new Error('This example workflow is read-only in the quick builder')
+ const next = await addWorkflowRequirement(workspaceId, existingWorkflow.id, { name: requirementName, roleId: parentId, minimumActors: 1, resilienceTarget: 1 })
+ return { catalog: next, nodeId: nodeId('workflow', existingWorkflow.id) }
+ }
+ const next = await createQuickWorkflow(workspaceId, { name, criticality: options.criticality, requirementName, roleId: parentId, minimumActors: 1, resilienceTarget: 1 })
+ return { catalog: next, nodeId: nodeId('workflow', findCreatedId(catalog.workflows, next.workflows)) }
+}
+
+async function assignRoleToMembers(workspaceId: string, catalog: DraftCatalog, roleId: string, memberIds: string[]) {
+ const selected = new Set(memberIds)
+ let latest = catalog
+ for (const member of catalog.members) {
+ if (!selected.has(member.id) || member.roleIds.includes(roleId)) continue
+ latest = await replaceMemberRoles(workspaceId, member.id, [...member.roleIds, roleId])
+ }
+ return latest
+}
+
+function findExistingEntity(entityType: EntityType, name: string, catalog: DraftCatalog) {
+ if (!name.trim()) return undefined
+ if (entityType === 'role') return catalog.roles.find((role) => normalizedName(role.name) === normalizedName(name))
+ if (entityType === 'workflow') return catalog.workflows.find((workflow) => normalizedName(workflow.name) === normalizedName(name))
+ return undefined
+}
+
+function normalizedName(value: string) { return value.trim().toLocaleLowerCase() }
+
+function enumChoices(values: string[]) {
+ return values.map((value) => {value[0] + value.slice(1).toLowerCase()} )
+}
+
+function nextOpenPosition(entityType: EntityType, nodes: CanvasNode[], requested?: XYPosition): XYPosition {
+ const nodeWidth = 220
+ const nodeHeight = 105
+ const isOpen = (position: XYPosition) => nodes.every((node) => Math.abs(node.position.x - position.x) >= nodeWidth || Math.abs(node.position.y - position.y) >= nodeHeight)
+ if (requested) {
+ const snapped = { x: Math.round(requested.x / 25) * 25, y: Math.round(requested.y / 25) * 25 }
+ for (let offset = 0; offset < 30; offset++) {
+ const position = { x: snapped.x + Math.floor(offset / 6) * 250, y: snapped.y + (offset % 6) * 125 }
+ if (isOpen(position)) return position
+ }
+ }
+ const typeNodes = nodes.filter((node) => node.data.entityType === entityType)
+ const baseX = typeNodes.length > 0 ? Math.min(...typeNodes.map((node) => node.position.x)) : 50 + entityTypes.indexOf(entityType) * 320
+ for (let slot = 0; slot < 60; slot++) {
+ const position = { x: baseX + Math.floor(slot / 6) * 250, y: 60 + (slot % 6) * 125 }
+ if (isOpen(position)) return position
+ }
+ return { x: baseX, y: 60 + typeNodes.length * 125 }
+}
+
+async function connectEntities(workspaceId: string, catalog: DraftCatalog, connection: Connection) {
+ const source = parseNodeId(connection.source)
+ const target = parseNodeId(connection.target)
+ if (source.type === 'team' && target.type === 'member') {
+ const member = catalog.members.find((candidate) => candidate.id === target.id)
+ if (!member) throw new Error('Member not found')
+ return updateDraftMember(workspaceId, member.id, memberInput(member, source.id))
+ }
+ if (source.type === 'member' && target.type === 'role') {
+ const member = catalog.members.find((candidate) => candidate.id === source.id)
+ if (!member) throw new Error('Member not found')
+ return replaceMemberRoles(workspaceId, member.id, [...new Set([...member.roleIds, target.id])])
+ }
+ throw new Error('Connect Team → Member or Member → Role. Choose a role when creating a workflow.')
+}
+
+function memberInput(member: DraftMember, teamId: string) {
+ return { teamId, employeeNumber: member.employeeNumber, name: member.name, email: member.email ?? '', status: member.status, region: member.region, shift: member.shift }
+}
+
+function isValidConnection(connection: Pick, catalog: DraftCatalog) {
+ const source = parseNodeId(connection.source)
+ const target = parseNodeId(connection.target)
+ if (source.type === 'team' && target.type === 'member') return true
+ if (source.type === 'member' && target.type === 'role') {
+ const member = catalog.members.find((candidate) => candidate.id === source.id)
+ return !member?.roleIds.includes(target.id)
+ }
+ return false
+}
+
+function parentOptions(entityType: EntityType, catalog: DraftCatalog) {
+ if (entityType === 'member') return catalog.teams.map((team) => ({ value: team.id, label: team.name }))
+ if (entityType === 'role') return catalog.members.map((member) => ({ value: member.id, label: member.name }))
+ if (entityType === 'workflow') return catalog.roles.map((role) => ({ value: role.id, label: role.name }))
+ return []
+}
+
+function defaultParentId(entityType: EntityType, catalog: DraftCatalog) {
+ return parentOptions(entityType, catalog)[0]?.value ?? ''
+}
+
+function prerequisiteMessage(entityType: EntityType, catalog: DraftCatalog) {
+ if (entityType === 'member' && catalog.teams.length === 0) return 'Create a team before adding a member.'
+ if (entityType === 'role' && catalog.members.length === 0) return 'Create a member before adding a role.'
+ if (entityType === 'workflow' && catalog.roles.length === 0) return 'Create a role before adding a workflow.'
+ return null
+}
+
+function relationshipLabel(entityType: EntityType) {
+ return { team: '', member: 'Place in team', role: 'Assign to member', workflow: 'Required role' }[entityType]
+}
+
+function paletteDetail(entityType: EntityType) {
+ return { team: 'Business group', member: 'Person or position', role: 'Access responsibility', workflow: 'Business process' }[entityType]
+}
+
+function namePlaceholder(entityType: EntityType) {
+ return { team: 'Platform Operations', member: 'Maya Singh', role: 'Release Manager', workflow: 'Production Deployment' }[entityType]
+}
+
+function entityIcon(entityType: GraphEntityType) {
+ return { team: 'T', member: 'M', role: 'R', responsibility: '✓', workflow: 'W' }[entityType]
+}
+
+function nodeId(type: GraphEntityType, id: string) { return `${type}:${id}` }
+function parseNodeId(value: string | null) {
+ const [type, ...id] = (value ?? '').split(':')
+ return { type: type as GraphEntityType, id: id.join(':') }
+}
+function findCreatedId(before: T[], after: T[]) {
+ const existing = new Set(before.map((item) => item.id))
+ const created = after.find((item) => !existing.has(item.id))
+ if (!created) throw new Error('Created object was not returned by the server')
+ return created.id
+}
+function positionKey(workspaceId: string) { return `roleimpact:canvas:${workspaceId}` }
+function readPositions(workspaceId: string): Record {
+ try { return JSON.parse(localStorage.getItem(positionKey(workspaceId)) ?? '{}') as Record } catch { return {} }
+}
+function removeSavedPosition(workspaceId: string, id: string) {
+ const positions = readPositions(workspaceId)
+ delete positions[id]
+ localStorage.setItem(positionKey(workspaceId), JSON.stringify(positions))
+}
diff --git a/frontend/src/components/workspaces/editor/WorkflowScenarioCanvas.test.ts b/frontend/src/components/workspaces/editor/WorkflowScenarioCanvas.test.ts
new file mode 100644
index 0000000..67dcd63
--- /dev/null
+++ b/frontend/src/components/workspaces/editor/WorkflowScenarioCanvas.test.ts
@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'vitest'
+import type { DraftCatalog } from '../../../api/draftCatalog'
+import { buildGraph } from './workflowScenarioGraph'
+import { findWorkflowRisks } from './workflowRisks'
+
+describe('workflow scenario layout', () => {
+ it('keeps each role and member in the lane of the workflow step they support', () => {
+ const risks = findWorkflowRisks(layoutCatalog).toReversed()
+ const bankRisk = risks.find((risk) => risk.roleId === 'role-bank')!
+ const graph = buildGraph(layoutCatalog, 'workflow-payment', risks, bankRisk.key, 'member-daniel')
+ const y = (nodeId: string) => graph.nodes.find((node) => node.id === nodeId)!.position.y
+
+ expect(y('role:role-invoice')).toBe(y('step:step-validate'))
+ expect(y('role:role-approver')).toBe(y('step:step-approve'))
+ expect(y('role:role-bank')).toBe(y('step:step-release'))
+ expect(y('member:member-daniel')).toBe(y('step:step-release'))
+ expect(y('step:step-validate')).toBeLessThan(y('step:step-approve'))
+ expect(y('step:step-approve')).toBeLessThan(y('step:step-release'))
+ })
+})
+
+const layoutCatalog: DraftCatalog = {
+ workspaceId: 'workspace-1',
+ teams: [{ id: 'team-finance', name: 'Finance', department: 'Finance', memberCount: 3 }],
+ members: [
+ { id: 'member-maya', teamId: 'team-finance', employeeNumber: null, name: 'Maya', email: null, status: 'ACTIVE', region: 'NORTH_AMERICA', shift: 'DAY', roleIds: ['role-invoice'] },
+ { id: 'member-priya', teamId: 'team-finance', employeeNumber: null, name: 'Priya', email: null, status: 'ACTIVE', region: 'NORTH_AMERICA', shift: 'DAY', roleIds: ['role-approver'] },
+ { id: 'member-daniel', teamId: 'team-finance', employeeNumber: null, name: 'Daniel', email: null, status: 'ACTIVE', region: 'NORTH_AMERICA', shift: 'DAY', roleIds: ['role-bank'] },
+ ],
+ roles: [
+ { id: 'role-bank', name: 'Bank Releaser', description: 'Releases payments', sensitivity: 'CRITICAL', ownerMemberId: null, memberCount: 1 },
+ { id: 'role-approver', name: 'Payment Approver', description: 'Approves payments', sensitivity: 'HIGH', ownerMemberId: null, memberCount: 1 },
+ { id: 'role-invoice', name: 'Invoice Processor', description: 'Validates invoices', sensitivity: 'MEDIUM', ownerMemberId: null, memberCount: 1 },
+ ],
+ workflows: [{
+ id: 'workflow-payment', name: 'Vendor Payment Run', criticality: 'CRITICAL', quickManaged: true,
+ requirements: [
+ { id: 'step-validate', name: 'Validate invoice', position: 1, minimumActors: 1, resilienceTarget: 1, requiredDepartment: null, requiredRegion: null, requiredShift: null, roleIds: ['role-invoice'] },
+ { id: 'step-approve', name: 'Approve payment', position: 2, minimumActors: 1, resilienceTarget: 1, requiredDepartment: null, requiredRegion: null, requiredShift: null, roleIds: ['role-approver'] },
+ { id: 'step-release', name: 'Release payment', position: 3, minimumActors: 1, resilienceTarget: 1, requiredDepartment: null, requiredRegion: null, requiredShift: null, roleIds: ['role-bank'] },
+ ],
+ }],
+}
diff --git a/frontend/src/components/workspaces/editor/WorkflowScenarioCanvas.tsx b/frontend/src/components/workspaces/editor/WorkflowScenarioCanvas.tsx
new file mode 100644
index 0000000..d69c9f2
--- /dev/null
+++ b/frontend/src/components/workspaces/editor/WorkflowScenarioCanvas.tsx
@@ -0,0 +1,128 @@
+import { useEffect, useMemo, useState } from 'react'
+import {
+ Background,
+ Controls,
+ Handle,
+ Position,
+ ReactFlow,
+ type Edge,
+ type NodeProps,
+} from '@xyflow/react'
+import '@xyflow/react/dist/style.css'
+import type { DraftCatalog } from '../../../api/draftCatalog'
+import type { DraftImpactResult } from '../../../api/draftImpact'
+import type { WorkflowRisk } from './workflowRisks'
+import { buildGraph, type ScenarioNode } from './workflowScenarioGraph'
+
+const nodeTypes = { scenario: ScenarioGraphNode }
+
+export default function WorkflowScenarioCanvas({ catalog, workflowId, risks, selectedRiskKey, selectedMemberId, result, onSelect, onRunScenario }: {
+ catalog: DraftCatalog
+ workflowId: string
+ risks: WorkflowRisk[]
+ selectedRiskKey: string
+ selectedMemberId: string
+ result?: DraftImpactResult
+ onSelect: (riskKey: string, memberId: string) => void
+ onRunScenario: (riskKey: string, memberId: string) => void
+}) {
+ const workflow = catalog.workflows.find((candidate) => candidate.id === workflowId)
+ const { nodes, edges } = useMemo(
+ () => buildGraph(catalog, workflowId, risks, selectedRiskKey, selectedMemberId, result),
+ [catalog, workflowId, risks, selectedRiskKey, selectedMemberId, result],
+ )
+ const [contextMenu, setContextMenu] = useState<{ x: number; y: number; memberId: string } | null>(null)
+ const selectedRisk = risks.find((risk) => risk.key === selectedRiskKey)
+ const selectedMember = selectedRisk?.members.find((member) => member.id === selectedMemberId)
+
+ useEffect(() => {
+ if (!contextMenu) return
+ const close = () => setContextMenu(null)
+ const closeOnEscape = (event: KeyboardEvent) => { if (event.key === 'Escape') close() }
+ window.addEventListener('click', close)
+ window.addEventListener('keydown', closeOnEscape)
+ return () => {
+ window.removeEventListener('click', close)
+ window.removeEventListener('keydown', closeOnEscape)
+ }
+ }, [contextMenu])
+
+ function selectNode(node: ScenarioNode) {
+ if (node.data.memberId) {
+ const matchingRisk = risks.find((risk) => risk.key === selectedRiskKey && risk.members.some((member) => member.id === node.data.memberId))
+ ?? risks.find((risk) => risk.members.some((member) => member.id === node.data.memberId))
+ if (matchingRisk) onSelect(matchingRisk.key, node.data.memberId)
+ return
+ }
+ if (node.data.riskKey) {
+ const risk = risks.find((candidate) => candidate.key === node.data.riskKey)
+ if (risk?.members[0]) onSelect(risk.key, risk.members[0].id)
+ }
+ }
+
+ return (
+
+
+
{result ? 'Tested scenario' : 'Current baseline'}
{workflow?.name}
+
+ Selected Covered Degraded Blocked or removed
+
+
+ Select a node to prepare a test, or right-click a member to run one immediately.
+ {selectedRisk && selectedMember ? {selectedMember.name} → {selectedRisk.roleName} onRunScenario(selectedRisk.key, selectedMember.id)}>Run selected what-if
: null}
+
+
+ nodes={nodes}
+ edges={edges}
+ nodeTypes={nodeTypes}
+ onNodeClick={(_, node) => { setContextMenu(null); selectNode(node) }}
+ onNodeContextMenu={(event, node) => {
+ if (!node.data.memberId) return
+ event.preventDefault()
+ setContextMenu({ x: event.clientX, y: event.clientY, memberId: node.data.memberId })
+ }}
+ nodesDraggable={false}
+ nodesConnectable={false}
+ edgesReconnectable={false}
+ zoomOnDoubleClick={false}
+ fitView
+ fitViewOptions={{ padding: 0.2, minZoom: 0.5, maxZoom: 0.95 }}
+ minZoom={0.4}
+ maxZoom={1.2}
+ >
+
+
+
+
+ {contextMenu ? { setContextMenu(null); onRunScenario(riskKey, memberId) }} /> : null}
+
+ )
+}
+
+function ScenarioContextMenu({ x, y, memberId, risks, onRun }: {
+ x: number
+ y: number
+ memberId: string
+ risks: WorkflowRisk[]
+ onRun: (riskKey: string, memberId: string) => void
+}) {
+ const member = risks.flatMap((risk) => risk.members).find((candidate) => candidate.id === memberId)
+ const uniqueRisks = [...new Map(risks.filter((risk) => risk.members.some((candidate) => candidate.id === memberId)).map((risk) => [risk.roleId, risk])).values()]
+ if (!member || uniqueRisks.length === 0) return null
+ return (
+ event.stopPropagation()}>
+ {member.name} Run a scenario
+ {uniqueRisks.map((risk) => onRun(risk.key, memberId)}>Test losing {risk.roleName} )}
+
+ )
+}
+
+function ScenarioGraphNode({ data, selected }: NodeProps) {
+ return (
+
+
+ {data.kind} {data.label} {data.subtitle}
+
+
+ )
+}
diff --git a/frontend/src/components/workspaces/editor/workflowRisks.ts b/frontend/src/components/workspaces/editor/workflowRisks.ts
new file mode 100644
index 0000000..5f4987c
--- /dev/null
+++ b/frontend/src/components/workspaces/editor/workflowRisks.ts
@@ -0,0 +1,62 @@
+import type { DraftCatalog, DraftMember, DraftWorkflowRequirement } from '../../../api/draftCatalog'
+
+export type WorkflowRiskMember = { id: string; name: string; eligible: boolean; losesCoverage: boolean }
+
+export type WorkflowRisk = {
+ key: string
+ workflowId: string
+ workflowName: string
+ criticality: string
+ requirementId: string
+ requirementName: string
+ minimumActors: number
+ resilienceTarget: number
+ roleId: string
+ roleName: string
+ members: WorkflowRiskMember[]
+ eligibleMembers: WorkflowRiskMember[]
+}
+
+export function findWorkflowRisks(catalog: DraftCatalog): WorkflowRisk[] {
+ const rolesById = new Map(catalog.roles.map((role) => [role.id, role]))
+ return catalog.workflows.flatMap((workflow) => workflow.requirements.flatMap((requirement) =>
+ requirement.roleIds.flatMap((roleId) => {
+ const role = rolesById.get(roleId)
+ if (!role) return []
+ const eligibleMembers = catalog.members
+ .filter((member) => member.roleIds.some((id) => requirement.roleIds.includes(id)) && isEligible(member, requirement, catalog))
+ .map((member) => ({ id: member.id, name: member.name, eligible: true, losesCoverage: false }))
+ const members = catalog.members
+ .filter((member) => member.roleIds.includes(roleId))
+ .map((member) => {
+ const eligible = isEligible(member, requirement, catalog)
+ const hasAlternativeRole = member.roleIds.some((id) => id !== roleId && requirement.roleIds.includes(id))
+ return { id: member.id, name: member.name, eligible, losesCoverage: eligible && !hasAlternativeRole }
+ })
+ return [{
+ key: `${workflow.id}:${requirement.id}:${roleId}`,
+ workflowId: workflow.id,
+ workflowName: workflow.name,
+ criticality: workflow.criticality,
+ requirementId: requirement.id,
+ requirementName: requirement.name,
+ minimumActors: requirement.minimumActors,
+ resilienceTarget: requirement.resilienceTarget,
+ roleId,
+ roleName: role.name,
+ members,
+ eligibleMembers,
+ }]
+ }),
+ ))
+}
+
+function isEligible(member: DraftMember, requirement: DraftWorkflowRequirement, catalog: DraftCatalog) {
+ if (member.status !== 'ACTIVE') return false
+ const team = catalog.teams.find((candidate) => candidate.id === member.teamId)
+ if (!team) return false
+ if (requirement.requiredDepartment && team.department !== requirement.requiredDepartment) return false
+ if (requirement.requiredRegion && member.region !== requirement.requiredRegion) return false
+ if (requirement.requiredShift && member.shift !== requirement.requiredShift) return false
+ return true
+}
diff --git a/frontend/src/components/workspaces/editor/workflowScenarioGraph.ts b/frontend/src/components/workspaces/editor/workflowScenarioGraph.ts
new file mode 100644
index 0000000..96deb48
--- /dev/null
+++ b/frontend/src/components/workspaces/editor/workflowScenarioGraph.ts
@@ -0,0 +1,118 @@
+import { MarkerType, type Edge, type Node } from '@xyflow/react'
+import type { DraftCatalog } from '../../../api/draftCatalog'
+import type { DraftImpactResult } from '../../../api/draftImpact'
+import type { WorkflowRisk } from './workflowRisks'
+
+type ScenarioState = 'baseline' | 'selected' | 'removed' | 'blocked' | 'degraded' | 'safe'
+type ScenarioKind = 'member' | 'role' | 'responsibility' | 'workflow'
+type ScenarioNodeData = {
+ label: string
+ subtitle: string
+ kind: ScenarioKind
+ state: ScenarioState
+ riskKey?: string
+ memberId?: string
+}
+export type ScenarioNode = Node
+
+const stateColors: Record = {
+ baseline: '#7f8798', selected: '#a78bfa', removed: '#fb7185', blocked: '#fb7185', degraded: '#fbbf24', safe: '#4ade80',
+}
+
+export function buildGraph(catalog: DraftCatalog, workflowId: string, risks: WorkflowRisk[], selectedRiskKey: string, selectedMemberId: string, result?: DraftImpactResult) {
+ const workflow = catalog.workflows.find((candidate) => candidate.id === workflowId)
+ if (!workflow) return { nodes: [] as ScenarioNode[], edges: [] as Edge[] }
+ const selectedRisk = risks.find((risk) => risk.key === selectedRiskKey)
+ const workflowImpact = result?.workflowImpacts.find((impact) => impact.workflowId === workflowId)
+ const requirements = workflow.requirements.toSorted((left, right) => left.position - right.position)
+ const requirementIndex = new Map(requirements.map((requirement, index) => [requirement.id, index]))
+ const roleIds = [...new Set(requirements.flatMap((requirement) => requirement.roleIds).filter((roleId) => risks.some((risk) => risk.roleId === roleId)))]
+ const roleLane = new Map(roleIds.map((roleId) => {
+ const lanes = risks.filter((risk) => risk.roleId === roleId).map((risk) => requirementIndex.get(risk.requirementId) ?? 0)
+ return [roleId, lanes.reduce((sum, lane) => sum + lane, 0) / Math.max(lanes.length, 1)] as const
+ }))
+ const members = catalog.members
+ .filter((member) => risks.some((risk) => risk.members.some((candidate) => candidate.id === member.id)))
+ .map((member) => {
+ const lanes = member.roleIds.filter((roleId) => roleLane.has(roleId)).map((roleId) => roleLane.get(roleId) ?? 0)
+ return { member, lane: Math.max(0, Math.min(requirements.length - 1, Math.round(lanes.reduce((sum, lane) => sum + lane, 0) / Math.max(lanes.length, 1)))) }
+ })
+ .toSorted((left, right) => left.lane - right.lane || left.member.name.localeCompare(right.member.name))
+ const nodes: ScenarioNode[] = []
+
+ const membersByLane = new Map()
+ members.forEach((member) => membersByLane.set(member.lane, [...(membersByLane.get(member.lane) ?? []), member]))
+ const laneY: number[] = []
+ let nextLaneY = 70
+ requirements.forEach((_, index) => {
+ const count = membersByLane.get(index)?.length ?? 0
+ laneY.push(nextLaneY + Math.max(0, (count - 1) * 52))
+ nextLaneY += Math.max(145, count * 104) + 24
+ })
+ members.forEach(({ member, lane }) => {
+ const laneMembers = membersByLane.get(lane) ?? []
+ const memberIndex = laneMembers.findIndex((candidate) => candidate.member.id === member.id)
+ const memberY = laneY[lane] - ((laneMembers.length - 1) * 104) / 2 + memberIndex * 104
+ nodes.push({
+ id: `member:${member.id}`, type: 'scenario', position: { x: 20, y: memberY },
+ data: { label: member.name, subtitle: member.status.toLowerCase(), kind: 'member', state: member.id === selectedMemberId ? 'selected' : 'baseline', memberId: member.id },
+ ariaLabel: `Member ${member.name}. Select to test their role access; open the context menu to run immediately.`,
+ })
+ })
+ roleIds.forEach((roleId) => {
+ const role = catalog.roles.find((candidate) => candidate.id === roleId)
+ const risk = risks.find((candidate) => candidate.roleId === roleId)
+ nodes.push({
+ id: `role:${roleId}`, type: 'scenario', position: { x: 285, y: interpolateLaneY(roleLane.get(roleId) ?? 0, laneY) },
+ data: { label: role?.name ?? 'Role', subtitle: `${role?.memberCount ?? 0} holders`, kind: 'role', state: roleId === selectedRisk?.roleId ? 'selected' : 'baseline', riskKey: risk?.key },
+ ariaLabel: `Role ${role?.name}. ${role?.memberCount ?? 0} holders.`,
+ })
+ })
+ requirements.forEach((requirement, index) => {
+ const impact = workflowImpact?.steps.find((step) => step.stepId === requirement.id)
+ const risk = risks.find((candidate) => candidate.requirementId === requirement.id)
+ nodes.push({
+ id: `step:${requirement.id}`, type: 'scenario', position: { x: 550, y: laneY[index] },
+ data: { label: requirement.name, subtitle: `minimum ${requirement.minimumActors} · healthy ${requirement.resilienceTarget}`, kind: 'responsibility', state: result ? statusState(impact?.scenarioStatus) : (risk?.key === selectedRiskKey ? 'selected' : 'baseline'), riskKey: risk?.key },
+ ariaLabel: `Workflow responsibility ${requirement.name}. Minimum ${requirement.minimumActors}; healthy target ${requirement.resilienceTarget}.`,
+ })
+ })
+ nodes.push({
+ id: `workflow:${workflow.id}`, type: 'scenario', position: { x: 830, y: laneY.reduce((sum, y) => sum + y, 0) / Math.max(laneY.length, 1) },
+ data: { label: workflow.name, subtitle: `${workflow.criticality.toLowerCase()} criticality`, kind: 'workflow', state: result ? statusState(workflowImpact?.scenarioStatus) : 'baseline' },
+ ariaLabel: `Workflow ${workflow.name}. ${workflow.criticality} criticality.`,
+ })
+
+ const nodeStates = new Map(nodes.map((node) => [node.id, node.data.state]))
+ const edges: Edge[] = []
+ members.forEach(({ member }) => roleIds.filter((roleId) => member.roleIds.includes(roleId)).forEach((roleId) => {
+ const removedAssignment = Boolean(result && member.id === selectedMemberId && roleId === selectedRisk?.roleId)
+ edges.push(scenarioEdge(`member-role:${member.id}:${roleId}`, `member:${member.id}`, `role:${roleId}`, 'holds', nodeStates, removedAssignment ? 'removed' : undefined))
+ }))
+ risks.forEach((risk) => edges.push(scenarioEdge(`role-step:${risk.roleId}:${risk.requirementId}`, `role:${risk.roleId}`, `step:${risk.requirementId}`, 'can perform', nodeStates, result ? nodeStates.get(`step:${risk.requirementId}`) : undefined)))
+ requirements.forEach((requirement) => edges.push(scenarioEdge(`step-workflow:${requirement.id}`, `step:${requirement.id}`, `workflow:${workflow.id}`, 'supports', nodeStates)))
+ return { nodes, edges }
+}
+
+function interpolateLaneY(lane: number, laneY: number[]) {
+ const lower = Math.floor(lane)
+ const upper = Math.ceil(lane)
+ if (lower === upper || !laneY[upper]) return laneY[lower] ?? 70
+ return laneY[lower] + (laneY[upper] - laneY[lower]) * (lane - lower)
+}
+
+function statusState(status?: 'OPERATIONAL' | 'DEGRADED' | 'BLOCKED'): ScenarioState {
+ if (status === 'BLOCKED') return 'blocked'
+ if (status === 'DEGRADED') return 'degraded'
+ return 'safe'
+}
+
+function scenarioEdge(id: string, source: string, target: string, label: string, states: Map, forcedState?: ScenarioState): Edge {
+ const state = forcedState ?? strongestState(states.get(source) ?? 'baseline', states.get(target) ?? 'baseline')
+ return { id, source, target, label, type: 'smoothstep', animated: state === 'blocked' || state === 'degraded', style: { stroke: stateColors[state], strokeWidth: state === 'baseline' ? 1.5 : 2.3, strokeDasharray: state === 'removed' ? '7 6' : undefined }, labelStyle: { fill: '#aeb5c7', fontSize: 9, fontWeight: 700 }, labelBgStyle: { fill: '#12151e', fillOpacity: 0.95 }, markerEnd: { type: MarkerType.ArrowClosed, color: stateColors[state], width: 16, height: 16 } }
+}
+
+function strongestState(left: ScenarioState, right: ScenarioState): ScenarioState {
+ const order: ScenarioState[] = ['baseline', 'safe', 'selected', 'degraded', 'removed', 'blocked']
+ return order.indexOf(left) > order.indexOf(right) ? left : right
+}
From 94a7ad3aa506dab81d6c2b39115730121048fe6e Mon Sep 17 00:00:00 2001
From: Sourav Chandhok
Date: Thu, 13 Aug 2026 22:57:22 -0400
Subject: [PATCH 2/2] Improve organization graph UX
---
frontend/src/App.css | 3 +++
frontend/src/App.test.tsx | 24 +++++++++++++++++--
.../workspaces/editor/DraftEditor.tsx | 8 ++++++-
.../workspaces/editor/DraftImpactTesting.tsx | 19 +++++----------
.../workspaces/editor/OrganizationCanvas.tsx | 14 +++++++----
5 files changed, 47 insertions(+), 21 deletions(-)
diff --git a/frontend/src/App.css b/frontend/src/App.css
index 8c7ccd1..7720ae7 100644
--- a/frontend/src/App.css
+++ b/frontend/src/App.css
@@ -1272,6 +1272,9 @@
}
.outcome-explanation {
+ position: sticky;
+ top: 0.75rem;
+ z-index: 12;
display: grid;
grid-template-columns: auto minmax(0, 1fr) auto;
align-items: start;
diff --git a/frontend/src/App.test.tsx b/frontend/src/App.test.tsx
index be7a43f..3555939 100644
--- a/frontend/src/App.test.tsx
+++ b/frontend/src/App.test.tsx
@@ -237,11 +237,16 @@ describe('App', () => {
await user.click(screen.getByRole('button', { name: 'Create role' }))
expect(await screen.findByText('Role created')).toBeInTheDocument()
- await user.click(screen.getByRole('button', { name: 'Add Workflow' }))
+ expect(within(screen.getByLabelText('Organization inventory')).queryByRole('button', { name: 'Delete object' })).not.toBeInTheDocument()
+
+ await user.click(screen.getByRole('button', { name: 'Build Workflow' }))
+ expect(await screen.findByRole('heading', { name: 'Create a workflow' })).toBeInTheDocument()
await user.type(screen.getByLabelText('Workflow name'), 'Production Deployment')
await user.selectOptions(screen.getByLabelText('Business criticality'), 'CRITICAL')
+ await user.type(screen.getByLabelText('Responsibility or step'), 'Release Manager responsibility')
await user.click(screen.getByRole('button', { name: 'Create workflow' }))
- expect(await screen.findByText('Workflow created')).toBeInTheDocument()
+ expect(await screen.findByText(/CRITICAL · 1 role responsibilities/)).toBeInTheDocument()
+ await user.click(screen.getByRole('button', { name: 'Organization map' }))
expect(screen.getByLabelText('Organization inventory')).toHaveTextContent('Production Deployment')
expect(screen.getByLabelText('Organization relationship canvas')).toBeInTheDocument()
expect(screen.getByText('5 objects · 4 connections')).toBeInTheDocument()
@@ -252,6 +257,19 @@ describe('App', () => {
expect(screen.getByLabelText('Workflow Production Deployment')).toBeInTheDocument()
expect(screen.getByLabelText('Continuity risks found')).toHaveTextContent('critical coverage gap')
+ const graphInventory = screen.getByLabelText('Organization inventory')
+ await user.click(within(graphInventory).getByRole('button', { name: 'Role' }))
+ await user.click(within(graphInventory).getByRole('button', { name: /Release Manager/ }))
+ expect(within(graphInventory).getByRole('button', { name: 'Delete object' })).toBeInTheDocument()
+ fireEvent.click(document.querySelector('.react-flow__pane')!)
+ expect(within(graphInventory).queryByRole('button', { name: 'Delete object' })).not.toBeInTheDocument()
+
+ await user.click(within(graphInventory).getByRole('button', { name: 'Workflow' }))
+ await user.click(within(graphInventory).getByRole('button', { name: /Production Deployment/ }))
+ await user.click(within(graphInventory).getByRole('button', { name: 'Edit workflow' }))
+ expect(await screen.findByRole('heading', { name: 'Create a workflow' })).toBeInTheDocument()
+ await user.click(screen.getByRole('button', { name: 'Organization map' }))
+
await user.click(screen.getByRole('button', { name: 'Test this risk' }))
expect(await screen.findByRole('heading', { name: 'Test a change before it happens' })).toBeInTheDocument()
expect(await screen.findByLabelText('Production Deployment baseline and impact graph')).toBeInTheDocument()
@@ -261,6 +279,8 @@ describe('App', () => {
await user.click(screen.getByRole('menuitem', { name: 'Test losing Release Manager' }))
expect(await screen.findByText('This responsibility is now blocked')).toBeInTheDocument()
expect(screen.getByText(/Maya Singh was the only eligible holder/)).toBeInTheDocument()
+ await user.click(screen.getByRole('button', { name: /Production Deployment.*would block/ }))
+ expect(screen.getByText('This responsibility is now blocked')).toBeInTheDocument()
expect(await screen.findByRole('heading', { name: 'A workflow would be blocked' })).toBeInTheDocument()
expect(screen.getByLabelText('Production Deployment baseline and impact graph')).toBeInTheDocument()
expect(screen.getByRole('button', { name: 'Reset to baseline' })).toBeInTheDocument()
diff --git a/frontend/src/components/workspaces/editor/DraftEditor.tsx b/frontend/src/components/workspaces/editor/DraftEditor.tsx
index 2d0a304..1535569 100644
--- a/frontend/src/components/workspaces/editor/DraftEditor.tsx
+++ b/frontend/src/components/workspaces/editor/DraftEditor.tsx
@@ -60,6 +60,12 @@ export default function DraftEditor({ workspaceId, isTemplateClone }: { workspac
window.requestAnimationFrame(() => editorRef.current?.scrollIntoView?.({ behavior: 'smooth', block: 'start' }))
}
+ function openInventory(nextStage?: EditorStage) {
+ if (nextStage) setStage(nextStage)
+ setView('inventory')
+ window.requestAnimationFrame(() => editorRef.current?.scrollIntoView?.({ behavior: 'smooth', block: 'start' }))
+ }
+
return (
@@ -89,7 +95,7 @@ export default function DraftEditor({ workspaceId, isTemplateClone }: { workspac
) : null}
{view === 'map' ? (
-
Opening the organization map…}> setView('inventory')} onTestImpact={() => setView('impact')} />
+
Opening the organization map…}> openInventory()} onOpenWorkflows={() => openInventory('workflows')} onTestImpact={() => setView('impact')} />
) : view === 'impact' ? (
Preparing impact testing…}> setView('map')} />
) : (
diff --git a/frontend/src/components/workspaces/editor/DraftImpactTesting.tsx b/frontend/src/components/workspaces/editor/DraftImpactTesting.tsx
index 413013b..f9bd0f4 100644
--- a/frontend/src/components/workspaces/editor/DraftImpactTesting.tsx
+++ b/frontend/src/components/workspaces/editor/DraftImpactTesting.tsx
@@ -1,4 +1,4 @@
-import { lazy, Suspense, useCallback, useEffect, useMemo, useRef, useState } from 'react'
+import { lazy, Suspense, useMemo, useState } from 'react'
import { useMutation } from '@tanstack/react-query'
import { runDraftImpactPreview, type DraftImpactResult } from '../../../api/draftImpact'
import type { DraftCatalog } from '../../../api/draftCatalog'
@@ -30,6 +30,7 @@ export default function DraftImpactTesting({ workspaceId, catalog, onBackToMap }
})
function chooseWorkflow(workflowId: string) {
+ if (workflowId === selectedWorkflowId) return
const firstRisk = testableRisks.find((risk) => risk.workflowId === workflowId)
setSelectedWorkflowId(workflowId)
setSelectedRiskKey(firstRisk?.key ?? '')
@@ -39,6 +40,7 @@ export default function DraftImpactTesting({ workspaceId, catalog, onBackToMap }
}
function chooseRisk(riskKey: string) {
+ if (riskKey === selectedRiskKey) return
const risk = workflowRisks.find((candidate) => candidate.key === riskKey)
setSelectedRiskKey(riskKey)
setSelectedMemberId(risk?.members[0]?.id ?? '')
@@ -47,6 +49,7 @@ export default function DraftImpactTesting({ workspaceId, catalog, onBackToMap }
}
function chooseScenario(riskKey: string, memberId: string) {
+ if (riskKey === selectedRiskKey && memberId === selectedMemberId) return
setSelectedRiskKey(riskKey)
setSelectedMemberId(memberId)
setShowOutcomeExplanation(false)
@@ -91,7 +94,7 @@ export default function DraftImpactTesting({ workspaceId, catalog, onBackToMap }
Step 2
Choose what to test Select a responsibility and one of its role holders. You can also select nodes directly in the graph.
Responsibility {workflowRisks.map((risk) => chooseRisk(risk.key)}>{risk.requirementName} {risk.roleName} {predictedOutcome(risk)} )}
- Role holder {selectedRisk.members.map((member) => { setSelectedMemberId(member.id); setShowOutcomeExplanation(false); mutation.reset() }}>{member.name} {member.eligible ? 'Eligible for this responsibility' : 'Not eligible under this responsibility’s conditions'} )}
+ Role holder {selectedRisk.members.map((member) => { if (member.id === selectedMemberId) return; setSelectedMemberId(member.id); setShowOutcomeExplanation(false); mutation.reset() }}>{member.name} {member.eligible ? 'Eligible for this responsibility' : 'Not eligible under this responsibility’s conditions'} )}
{coverageHeading(selectedRisk, selectedMember.losesCoverage)} {selectedRisk.eligibleMembers.length} eligible now · minimum {selectedRisk.minimumActors} · healthy target {selectedRisk.resilienceTarget}.
What if {selectedMember.name} loses {selectedRisk.roleName}? No organization data will be changed.
runScenario(selectedRisk.key, selectedMember.id)}>{mutation.isPending ? 'Calculating impact…' : 'Run this what-if test'} {mutation.data ? { setShowOutcomeExplanation(false); mutation.reset() }}>Reset to baseline : null}
@@ -105,7 +108,6 @@ export default function DraftImpactTesting({ workspaceId, catalog, onBackToMap }
}
function OutcomeExplanation({ risk, member, onDismiss }: { risk: WorkflowRisk; member: WorkflowRisk['members'][number]; onDismiss: () => void }) {
- const timer = useRef | null>(null)
const survivors = risk.eligibleMembers.filter((candidate) => candidate.id !== member.id || !member.losesCoverage)
const tone = survivors.length < risk.minimumActors ? 'blocked' : survivors.length < risk.resilienceTarget ? 'degraded' : 'safe'
const heading = tone === 'blocked' ? 'This responsibility is now blocked' : tone === 'degraded' ? 'It still works, but resilience is reduced' : 'Coverage remains healthy'
@@ -113,17 +115,8 @@ function OutcomeExplanation({ risk, member, onDismiss }: { risk: WorkflowRisk; m
? `${member.name} was the only eligible holder. No one can now perform ${risk.requirementName}.`
: `${member.name} loses ${risk.roleName}, but ${formatNames(survivors.map((survivor) => survivor.name))} ${survivors.length === 1 ? 'still provides' : 'still provide'} coverage.`
- const scheduleDismiss = useCallback(() => {
- if (timer.current) window.clearTimeout(timer.current)
- timer.current = window.setTimeout(onDismiss, 8000)
- }, [onDismiss])
- useEffect(() => {
- scheduleDismiss()
- return () => { if (timer.current) window.clearTimeout(timer.current) }
- }, [scheduleDismiss])
-
return (
- { if (timer.current) window.clearTimeout(timer.current) }} onMouseLeave={scheduleDismiss}>
+
{tone === 'blocked' ? '!' : tone === 'degraded' ? '△' : '✓'}
{heading} {coverageText}
Rule: {survivors.length} eligible after change · minimum {risk.minimumActors} to operate · {risk.resilienceTarget} for healthy coverage.
×
diff --git a/frontend/src/components/workspaces/editor/OrganizationCanvas.tsx b/frontend/src/components/workspaces/editor/OrganizationCanvas.tsx
index 2c317d5..3ebfae7 100644
--- a/frontend/src/components/workspaces/editor/OrganizationCanvas.tsx
+++ b/frontend/src/components/workspaces/editor/OrganizationCanvas.tsx
@@ -60,6 +60,7 @@ export default function OrganizationCanvas(props: {
catalog: DraftCatalog
initialFocus: boolean
onOpenInventory: () => void
+ onOpenWorkflows: () => void
onTestImpact: () => void
}) {
return (
@@ -69,11 +70,12 @@ export default function OrganizationCanvas(props: {
)
}
-function OrganizationCanvasInner({ workspaceId, catalog, initialFocus, onOpenInventory, onTestImpact }: {
+function OrganizationCanvasInner({ workspaceId, catalog, initialFocus, onOpenInventory, onOpenWorkflows, onTestImpact }: {
workspaceId: string
catalog: DraftCatalog
initialFocus: boolean
onOpenInventory: () => void
+ onOpenWorkflows: () => void
onTestImpact: () => void
}) {
const queryClient = useQueryClient()
@@ -195,15 +197,15 @@ function OrganizationCanvasInner({ workspaceId, catalog, initialFocus, onOpenInv
{
event.dataTransfer.setData('application/roleimpact-node', entityType)
event.dataTransfer.effectAllowed = 'copy'
}}
- onClick={() => beginCreate(entityType)}
+ onClick={() => entityType === 'workflow' ? onOpenWorkflows() : beginCreate(entityType)}
>
{entityIcon(entityType)}
{typeLabels[entityType]}
@@ -241,6 +243,7 @@ function OrganizationCanvasInner({ workspaceId, catalog, initialFocus, onOpenInv
nodesDraggable={scope === 'full'}
onNodeDragStop={(_, node) => { if (scope === 'full') savePosition(node) }}
onNodeClick={(_, node) => setSelectedNodeId(node.id)}
+ onPaneClick={() => setSelectedNodeId(null)}
onConnect={(connection) => connectionMutation.mutate(connection)}
isValidConnection={(connection) => isValidConnection(connection, catalog)}
fitView
@@ -291,6 +294,7 @@ function OrganizationCanvasInner({ workspaceId, catalog, initialFocus, onOpenInv
{selectedNode.data.detail}
{(selectedNode.data.entityType === 'member' || selectedNode.data.entityType === 'role') ? Test impact : null}
+ {selectedNode.data.entityType === 'workflow' ? Edit workflow : null}
{selectedNode.data.entityType !== 'responsibility' ? { deleteMutation.reset(); setPendingDelete(selectedNode) }}>Delete object : null}
@@ -310,7 +314,7 @@ function OrganizationCanvasInner({ workspaceId, catalog, initialFocus, onOpenInv
localStorage.setItem(positionKey(workspaceId), JSON.stringify(positions))
}
queryClient.setQueryData(['draft-catalog', workspaceId], nextCatalog)
- setSelectedNodeId(createdId)
+ setSelectedNodeId(null)
setPendingCreate(null)
setNotice(successMessage ?? `${typeLabels[pendingCreate.entityType]} created`)
}}