Composite Pattern: Treating Groups and Individuals the Same

In software design, complexity often arises not from individual parts but from how parts relate to each other — especially when some parts contain other parts.

The Composite Pattern offers a way to treat individual objects and compositions of objects uniformly.

---

What is the Composite Pattern?

The Composite Pattern lets you build tree structures of objects where individual objects and groups of objects are treated the same way.

It is especially useful when:

• You want to abstract tree-like recursive structures
• You need to treat single and grouped entities uniformly
• You want to delegate responsibility down a hierarchy

---

Real-World Analogy: Company Org Chart

In a company:

• An Employee might be an individual contributor
• A Manager might manage other employees (or even other managers)

But both share similar behaviors like:

• get_salary()
• display_role()

A CEO doesn’t care if it’s a manager or an individual contributor — they just call the same method. That’s the essence of Composite.

---

Real Backend Example: Permission System

Imagine a permission system where:

• You have individual permissions (e.g.,
  read
  ,
  write
  )
• And roles that group those permissions (e.g.,
  admin
  =
  read + write + delete
  )
• And maybe even nested roles (e.g.,
  super_admin
  =
  admin + audit
  )

You want to be able to ask any permission or group:

has_permission("delete")

---

Step 1: Component Interface

# permissions/base.py
from abc import ABC, abstractmethod

class PermissionComponent(ABC):
    @abstractmethod
    def has_permission(self, action: str) -> bool:
        pass

---

Step 2: Leaf - Individual Permission

# permissions/leaf.py
from permissions.base import PermissionComponent

class SimplePermission(PermissionComponent):
    def __init__(self, name: str):
        self.name = name

    def has_permission(self, action: str) -> bool:
        return self.name == action

---

Step 3: Composite - Role with Sub-Permissions

# permissions/composite.py
from permissions.base import PermissionComponent

class Role(PermissionComponent):
    def __init__(self, name: str):
        self.name = name
        self.children: list[PermissionComponent] = []

    def add(self, component: PermissionComponent):
        self.children.append(component)

    def has_permission(self, action: str) -> bool:
        return any(child.has_permission(action) for child in self.children)

---

Step 4: Using the Composite

# main.py
from permissions.leaf import SimplePermission
from permissions.composite import Role

# Create simple permissions
read = SimplePermission("read")
write = SimplePermission("write")
delete = SimplePermission("delete")

# Create a role with some permissions
admin = Role("admin")
admin.add(read)
admin.add(write)
admin.add(delete)

# Nested role
super_admin = Role("super_admin")
super_admin.add(admin)
super_admin.add(SimplePermission("audit"))

# Test it
print(admin.has_permission("write"))         # True
print(admin.has_permission("audit"))         # False
print(super_admin.has_permission("audit"))   # True

---

When to Use the Composite Pattern in Backend Systems

• Authorization trees: roles, groups, nested permissions
• Menu or routing trees: hierarchical navigations or page layouts
• Document structures: sections with nested sub-sections
• Notification flows: chain of notifications sent to multiple layers (email + SMS + push)

---

Why It Matters

• Makes recursive data structures easy to model
• Allows for elegant tree traversal
• Clean abstraction for both individual and composite objects

---

Tips & Best Practices

• Your components (leaf and composite) should implement the same interface
• Favor composition over inheritance when nesting objects
• It’s often paired with Iterator pattern if traversal needs to be externalized

---

Closing Thoughts

The Composite Pattern helps keep backend logic clean when dealing with recursive, nested, or hierarchical systems. Instead of manually checking types or writing special handling logic, just treat everything as a component.

By making your backend work more like a tree and less like a tangle, you can simplify logic while still supporting rich structure.