490 lines
14 KiB
Markdown
490 lines
14 KiB
Markdown
# Component Relationships
|
|
|
|
This document details how different components of the Go Platform interact with each other, including dependency relationships, data flow, and integration patterns.
|
|
|
|
## Table of Contents
|
|
|
|
- [Core Component Dependencies](#core-component-dependencies)
|
|
- [Module to Core Integration](#module-to-core-integration)
|
|
- [Service Interaction Patterns](#service-interaction-patterns)
|
|
- [Data Flow Patterns](#data-flow-patterns)
|
|
- [Dependency Graph](#dependency-graph)
|
|
|
|
## Core Component Dependencies
|
|
|
|
The core kernel components have well-defined dependencies that form the foundation of the platform.
|
|
|
|
```mermaid
|
|
graph TD
|
|
subgraph "Foundation Layer"
|
|
Config[Config Manager]
|
|
Logger[Logger Service]
|
|
end
|
|
|
|
subgraph "DI Layer"
|
|
DI[DI Container]
|
|
end
|
|
|
|
subgraph "Infrastructure Layer"
|
|
DB[Database Client]
|
|
Cache[Cache Client]
|
|
EventBus[Event Bus]
|
|
Scheduler[Scheduler]
|
|
end
|
|
|
|
subgraph "Service Registry"
|
|
Registry[Service Registry<br/>Consul]
|
|
end
|
|
|
|
subgraph "Observability Layer"
|
|
Metrics[Metrics Registry]
|
|
Health[Health Registry]
|
|
Tracer[OpenTelemetry Tracer]
|
|
end
|
|
|
|
Config --> Logger
|
|
Config --> DI
|
|
Logger --> DI
|
|
|
|
DI --> DB
|
|
DI --> Cache
|
|
DI --> EventBus
|
|
DI --> Scheduler
|
|
DI --> Metrics
|
|
DI --> Health
|
|
DI --> Tracer
|
|
DI --> Registry
|
|
|
|
DB --> Tracer
|
|
Cache --> Tracer
|
|
EventBus --> Tracer
|
|
|
|
style Config fill:#4a90e2,stroke:#2e5c8a,stroke-width:3px,color:#fff
|
|
style DI fill:#50c878,stroke:#2e7d4e,stroke-width:3px,color:#fff
|
|
```
|
|
|
|
## Service to Service Integration
|
|
|
|
Feature services integrate with core services through service client interfaces. All communication uses gRPC (primary) or HTTP (fallback). Services discover each other via the service registry (Consul).
|
|
|
|
```mermaid
|
|
graph LR
|
|
subgraph "Feature Service (e.g., Blog)"
|
|
ModuleHandler[Module Handler]
|
|
ModuleService[Module Service]
|
|
ModuleRepo[Module Repository]
|
|
end
|
|
|
|
subgraph "Service Clients"
|
|
AuthClient[Auth Service Client<br/>gRPC]
|
|
AuthzClient[Authz Service Client<br/>gRPC]
|
|
IdentityClient[Identity Service Client<br/>gRPC]
|
|
AuditClient[Audit Service Client<br/>gRPC]
|
|
end
|
|
|
|
subgraph "Service Registry"
|
|
Registry[Consul<br/>Service Discovery]
|
|
end
|
|
|
|
subgraph "Core Services"
|
|
AuthService[Auth Service<br/>:8081]
|
|
AuthzService[Authz Service<br/>:8083]
|
|
IdentityService[Identity Service<br/>:8082]
|
|
AuditService[Audit Service<br/>:8084]
|
|
EventBusService[Event Bus<br/>Kafka]
|
|
CacheService[Cache Service<br/>Redis]
|
|
end
|
|
|
|
subgraph "Infrastructure"
|
|
DBClient[Database Client]
|
|
CacheClient[Cache Client]
|
|
QueueClient[Message Queue]
|
|
end
|
|
|
|
ModuleHandler --> ModuleService
|
|
|
|
ModuleService -->|gRPC| AuthClient
|
|
ModuleService -->|gRPC| AuthzClient
|
|
ModuleService -->|gRPC| IdentityClient
|
|
ModuleService -->|gRPC| AuditClient
|
|
ModuleService --> ModuleRepo
|
|
ModuleService --> EventBusService
|
|
ModuleService --> CacheService
|
|
|
|
AuthClient -->|Discover| Registry
|
|
AuthzClient -->|Discover| Registry
|
|
IdentityClient -->|Discover| Registry
|
|
AuditClient -->|Discover| Registry
|
|
|
|
Registry --> AuthService
|
|
Registry --> AuthzService
|
|
Registry --> IdentityService
|
|
Registry --> AuditService
|
|
|
|
AuthClient --> AuthService
|
|
AuthzClient --> AuthzService
|
|
IdentityClient --> IdentityService
|
|
AuditClient --> AuditService
|
|
|
|
ModuleRepo --> DBClient
|
|
CacheService --> CacheClient
|
|
EventBusService --> QueueClient
|
|
|
|
style ModuleService fill:#7b68ee,stroke:#5a4fcf,stroke-width:2px,color:#fff
|
|
style Registry fill:#50c878,stroke:#2e7d4e,stroke-width:3px,color:#fff
|
|
style AuthService fill:#ff6b6b,stroke:#c92a2a,stroke-width:2px,color:#fff
|
|
style DBClient fill:#50c878,stroke:#2e7d4e,stroke-width:2px,color:#fff
|
|
style AuthClient fill:#50c878,stroke:#2e7d4e,stroke-width:2px,color:#fff
|
|
style AuthzClient fill:#50c878,stroke:#2e7d4e,stroke-width:2px,color:#fff
|
|
style IdentityClient fill:#50c878,stroke:#2e7d4e,stroke-width:2px,color:#fff
|
|
style AuditClient fill:#50c878,stroke:#2e7d4e,stroke-width:2px,color:#fff
|
|
```
|
|
|
|
## Service Interaction Patterns
|
|
|
|
### Authentication Flow
|
|
|
|
```mermaid
|
|
sequenceDiagram
|
|
participant Client
|
|
participant Router
|
|
participant AuthMiddleware
|
|
participant AuthService
|
|
participant TokenProvider
|
|
participant UserRepo
|
|
participant DB
|
|
|
|
Client->>Router: POST /api/v1/auth/login
|
|
Router->>AuthMiddleware: Extract credentials
|
|
AuthMiddleware->>AuthService: Authenticate(email, password)
|
|
AuthService->>UserRepo: FindByEmail(email)
|
|
UserRepo->>DB: Query user
|
|
DB-->>UserRepo: User data
|
|
UserRepo-->>AuthService: User entity
|
|
AuthService->>AuthService: Verify password
|
|
AuthService->>TokenProvider: GenerateAccessToken(user)
|
|
AuthService->>TokenProvider: GenerateRefreshToken(user)
|
|
TokenProvider-->>AuthService: Tokens
|
|
AuthService->>DB: Store refresh token
|
|
AuthService-->>AuthMiddleware: Auth response
|
|
AuthMiddleware-->>Router: Tokens
|
|
Router-->>Client: JSON response with tokens
|
|
```
|
|
|
|
### Authorization Flow
|
|
|
|
```mermaid
|
|
sequenceDiagram
|
|
participant Request
|
|
participant AuthzMiddleware
|
|
participant Authorizer
|
|
participant PermissionResolver
|
|
participant Cache
|
|
participant UserRepo
|
|
participant RoleRepo
|
|
participant DB
|
|
|
|
Request->>AuthzMiddleware: HTTP request + permission
|
|
AuthzMiddleware->>Authorizer: Authorize(ctx, permission)
|
|
Authorizer->>Authorizer: Extract user from context
|
|
Authorizer->>PermissionResolver: HasPermission(user, permission)
|
|
PermissionResolver->>Cache: Check cache
|
|
Cache-->>PermissionResolver: Cache miss
|
|
|
|
PermissionResolver->>UserRepo: GetUserRoles(userID)
|
|
UserRepo->>DB: Query user_roles
|
|
DB-->>UserRepo: Role IDs
|
|
UserRepo-->>PermissionResolver: Roles
|
|
|
|
PermissionResolver->>RoleRepo: GetRolePermissions(roleIDs)
|
|
RoleRepo->>DB: Query role_permissions
|
|
DB-->>RoleRepo: Permissions
|
|
RoleRepo-->>PermissionResolver: Permission list
|
|
|
|
PermissionResolver->>PermissionResolver: Check if permission in list
|
|
PermissionResolver->>Cache: Store in cache
|
|
PermissionResolver-->>Authorizer: Has permission: true/false
|
|
Authorizer-->>AuthzMiddleware: Authorized or error
|
|
AuthzMiddleware-->>Request: Continue or 403
|
|
```
|
|
|
|
### Event Publishing Flow
|
|
|
|
```mermaid
|
|
sequenceDiagram
|
|
participant ModuleService
|
|
participant EventBus
|
|
participant Kafka
|
|
participant Subscriber1
|
|
participant Subscriber2
|
|
|
|
ModuleService->>EventBus: Publish(topic, event)
|
|
EventBus->>EventBus: Serialize event
|
|
EventBus->>Kafka: Send to topic
|
|
Kafka-->>EventBus: Acknowledged
|
|
|
|
Kafka->>Subscriber1: Deliver event
|
|
Kafka->>Subscriber2: Deliver event
|
|
|
|
Subscriber1->>Subscriber1: Process event
|
|
Subscriber2->>Subscriber2: Process event
|
|
```
|
|
|
|
## Data Flow Patterns
|
|
|
|
### Request to Response Flow
|
|
|
|
```mermaid
|
|
graph LR
|
|
Client[Client] -->|HTTP Request| LB[Load Balancer]
|
|
LB -->|Route| Server1[Instance 1]
|
|
LB -->|Route| Server2[Instance 2]
|
|
|
|
Server1 --> AuthMW[Auth Middleware]
|
|
Server1 --> AuthzMW[Authz Middleware]
|
|
Server1 --> RateLimit[Rate Limiter]
|
|
Server1 --> Handler[Request Handler]
|
|
Server1 --> Service[Domain Service]
|
|
Server1 --> Cache[Cache Check]
|
|
Server1 --> Repo[Repository]
|
|
Server1 --> DB[(Database)]
|
|
|
|
Service --> EventBus[Event Bus]
|
|
Service --> Audit[Audit Log]
|
|
|
|
Handler -->|Response| Server1
|
|
Server1 -->|HTTP Response| LB
|
|
LB -->|Response| Client
|
|
|
|
style Server1 fill:#4a90e2,stroke:#2e5c8a,stroke-width:2px,color:#fff
|
|
style Service fill:#50c878,stroke:#2e7d4e,stroke-width:2px,color:#fff
|
|
```
|
|
|
|
### Caching Flow
|
|
|
|
```mermaid
|
|
graph TD
|
|
Request[Service Request] --> CacheCheck{Cache Hit?}
|
|
CacheCheck -->|Yes| CacheGet[Get from Cache]
|
|
CacheCheck -->|No| DBQuery[Query Database]
|
|
DBQuery --> DBResponse[Database Response]
|
|
DBResponse --> CacheStore[Store in Cache]
|
|
CacheStore --> Return[Return Data]
|
|
CacheGet --> Return
|
|
|
|
style CacheCheck fill:#4a90e2,stroke:#2e5c8a,stroke-width:2px,color:#fff
|
|
style CacheGet fill:#50c878,stroke:#2e7d4e,stroke-width:2px,color:#fff
|
|
style DBQuery fill:#ff6b6b,stroke:#c92a2a,stroke-width:2px,color:#fff
|
|
```
|
|
|
|
## Dependency Graph
|
|
|
|
Complete dependency graph showing all components and their relationships.
|
|
|
|
```mermaid
|
|
graph TB
|
|
subgraph "Application Entry"
|
|
Main[Main Application]
|
|
end
|
|
|
|
subgraph "Core Kernel"
|
|
Config[Config]
|
|
Logger[Logger]
|
|
DI[DI Container]
|
|
ModuleLoader[Module Loader]
|
|
end
|
|
|
|
subgraph "Security"
|
|
Auth[Auth]
|
|
Authz[Authz]
|
|
Identity[Identity]
|
|
Audit[Audit]
|
|
end
|
|
|
|
subgraph "Infrastructure"
|
|
DB[Database]
|
|
Cache[Cache]
|
|
EventBus[Event Bus]
|
|
Scheduler[Scheduler]
|
|
BlobStore[Blob Store]
|
|
Notifier[Notifier]
|
|
end
|
|
|
|
subgraph "Observability"
|
|
Metrics[Metrics]
|
|
Health[Health]
|
|
Tracer[Tracer]
|
|
ErrorBus[Error Bus]
|
|
end
|
|
|
|
subgraph "Module"
|
|
ModuleHandler[Module Handler]
|
|
ModuleService[Module Service]
|
|
ModuleRepo[Module Repo]
|
|
end
|
|
|
|
Main --> Config
|
|
Main --> Logger
|
|
Main --> DI
|
|
Main --> ModuleLoader
|
|
|
|
Config --> Logger
|
|
Config --> DI
|
|
|
|
DI --> Auth
|
|
DI --> Authz
|
|
DI --> Identity
|
|
DI --> Audit
|
|
DI --> DB
|
|
DI --> Cache
|
|
DI --> EventBus
|
|
DI --> Scheduler
|
|
DI --> BlobStore
|
|
DI --> Notifier
|
|
DI --> Metrics
|
|
DI --> Health
|
|
DI --> Tracer
|
|
DI --> ErrorBus
|
|
|
|
Auth --> Identity
|
|
Auth --> DB
|
|
Authz --> Identity
|
|
Authz --> Cache
|
|
Authz --> Audit
|
|
Audit --> DB
|
|
Audit --> Logger
|
|
|
|
ModuleLoader --> DI
|
|
ModuleHandler --> ModuleService
|
|
ModuleService --> ModuleRepo
|
|
ModuleService -->|gRPC| Auth
|
|
ModuleService -->|gRPC| Authz
|
|
ModuleService -->|gRPC| Identity
|
|
ModuleService -->|gRPC| Audit
|
|
ModuleService --> EventBus
|
|
ModuleService --> Cache
|
|
ModuleRepo --> DB
|
|
|
|
Scheduler --> Cache
|
|
Notifier --> EventBus
|
|
|
|
ErrorBus --> Logger
|
|
|
|
DB --> Tracer
|
|
Cache --> Tracer
|
|
EventBus --> Tracer
|
|
|
|
style Main fill:#4a90e2,stroke:#2e5c8a,stroke-width:4px,color:#fff
|
|
style DI fill:#50c878,stroke:#2e7d4e,stroke-width:3px,color:#fff
|
|
style ModuleService fill:#7b68ee,stroke:#5a4fcf,stroke-width:2px,color:#fff
|
|
```
|
|
|
|
## Component Interaction Matrix
|
|
|
|
| Component | Depends On | Used By |
|
|
|-----------|-----------|---------|
|
|
| Config | None | All components |
|
|
| Logger | Config | All components |
|
|
| DI Container | Config, Logger | All components |
|
|
| Auth Service | Identity, DB | Auth Middleware, Modules |
|
|
| Authz Service | Identity, Cache, Audit | Authz Middleware, Modules |
|
|
| Identity Service | DB, Cache, Notifier | Auth, Authz, Modules |
|
|
| Database Client | Config, Logger, Tracer | All repositories |
|
|
| Cache Client | Config, Logger | Authz, Scheduler, Modules |
|
|
| Event Bus | Config, Logger, Tracer | Modules, Notifier |
|
|
| Scheduler | Cache, Logger | Modules |
|
|
| Error Bus | Logger | All components (via panic recovery) |
|
|
|
|
## Integration Patterns
|
|
|
|
### Module Service Integration
|
|
|
|
```mermaid
|
|
graph TB
|
|
subgraph "Module Layer"
|
|
Handler[HTTP Handler]
|
|
Service[Domain Service]
|
|
Repo[Repository]
|
|
end
|
|
|
|
subgraph "Core Services"
|
|
Auth[Auth Service]
|
|
Authz[Authz Service]
|
|
EventBus[Event Bus]
|
|
Cache[Cache]
|
|
Audit[Audit]
|
|
end
|
|
|
|
subgraph "Infrastructure"
|
|
DB[(Database)]
|
|
Redis[(Redis)]
|
|
Kafka[Kafka]
|
|
end
|
|
|
|
Handler --> Auth
|
|
Handler --> Authz
|
|
Handler --> Service
|
|
|
|
Service --> Repo
|
|
Service --> EventBus
|
|
Service --> Cache
|
|
Service --> Audit
|
|
|
|
Repo --> DB
|
|
Cache --> Redis
|
|
EventBus --> Kafka
|
|
Audit --> DB
|
|
|
|
style Service fill:#7b68ee,stroke:#5a4fcf,stroke-width:2px,color:#fff
|
|
style Auth fill:#4a90e2,stroke:#2e5c8a,stroke-width:2px,color:#fff
|
|
style DB fill:#50c878,stroke:#2e7d4e,stroke-width:2px,color:#fff
|
|
```
|
|
|
|
### Cross-Service Communication
|
|
|
|
```mermaid
|
|
graph LR
|
|
subgraph "Blog Service"
|
|
BlogService[Blog Service]
|
|
end
|
|
|
|
subgraph "Analytics Service"
|
|
AnalyticsService[Analytics Service]
|
|
end
|
|
|
|
subgraph "Service Clients"
|
|
AuthzClient[Authz Service Client]
|
|
IdentityClient[Identity Service Client]
|
|
end
|
|
|
|
subgraph "Core Services"
|
|
EventBus[Event Bus<br/>Kafka]
|
|
AuthzService[Authz Service<br/>:8083]
|
|
IdentityService[Identity Service<br/>:8082]
|
|
Cache[Cache<br/>Redis]
|
|
end
|
|
|
|
BlogService -->|gRPC| AuthzClient
|
|
BlogService -->|gRPC| IdentityClient
|
|
BlogService -->|Publish Event| EventBus
|
|
EventBus -->|Subscribe| AnalyticsService
|
|
BlogService -->|Cache Access| Cache
|
|
AnalyticsService -->|Cache Access| Cache
|
|
|
|
AuthzClient --> AuthzService
|
|
IdentityClient --> IdentityService
|
|
|
|
style BlogService fill:#7b68ee,stroke:#5a4fcf,stroke-width:2px,color:#fff
|
|
style AnalyticsService fill:#7b68ee,stroke:#5a4fcf,stroke-width:2px,color:#fff
|
|
style EventBus fill:#4a90e2,stroke:#2e5c8a,stroke-width:3px,color:#fff
|
|
style AuthzClient fill:#50c878,stroke:#2e7d4e,stroke-width:2px,color:#fff
|
|
style IdentityClient fill:#50c878,stroke:#2e7d4e,stroke-width:2px,color:#fff
|
|
```
|
|
|
|
## Next Steps
|
|
|
|
- [System Architecture](./architecture.md) - Overall system architecture
|
|
- [Module Architecture](./architecture-modules.md) - Module design and integration
|
|
- [Module Requirements](./module-requirements.md) - Detailed module requirements
|
|
|