moicle 1.3.1 → 1.6.0

package/README.md

@@ -60,25 +60,27 @@ moicle install
 
 ## What's Included
 
-### Architecture References (7)
+### Architecture References (8)
 
 | File | Description |
 |------|-------------|
 | `clean-architecture.md` | Core Clean Architecture principles |
 | `go-backend.md` | Go + Gin project structure |
 | `laravel-backend.md` | Laravel + PHP project structure |
+| `nodejs-nestjs.md` | Node.js + NestJS + Prisma (DDD + Hexagonal) |
 | `react-frontend.md` | React + Vite project structure |
 | `remix-fullstack.md` | Remix fullstack structure |
 | `flutter-mobile.md` | Flutter mobile structure |
 | `monorepo.md` | Monorepo structure |
 
-### Developer Agents (5)
+### Developer Agents (6)
 
 | Agent | Description |
 |-------|-------------|
 | `@flutter-mobile-dev` | Flutter/Dart mobile & desktop development |
 | `@go-backend-dev` | Go + Gin backend API development |
 | `@laravel-backend-dev` | Laravel + PHP backend API development |
+| `@nodejs-backend-dev` | Node.js + NestJS + Prisma backend development |
 | `@react-frontend-dev` | React + TypeScript frontend development |
 | `@remix-fullstack-dev` | Remix full-stack development |
 
@@ -105,22 +107,31 @@ moicle install
 | `/brainstorm` | Brainstorm ideas with 6 frameworks |
 | `/doc` | Scan project and generate documentation |
 
-### Skills (12)
+### Skills (21)
 
 | Skill | Trigger |
 |-------|---------|
 | `new-feature` | "implement feature", "add feature", "build feature" |
 | `hotfix` | "fix bug", "hotfix", "urgent fix", "production issue" |
 | `pr-review` | "review pr", "check pr", "review code" |
-| `release` | "release", "deploy", "ship" |
+| `review-changes` | "review changes", "review branch", "check branch", "review before pr" |
+| `release` | "release", "deploy" |
+| `deep-debug` | "deep debug", "trace bug", "find root cause", "hard bug" |
 | `refactor` | "refactor", "clean up", "improve code" |
 | `tdd` | "tdd", "test first", "test driven" |
 | `onboarding` | "explain codebase", "onboard", "new to project" |
-| `spike` | "spike", "research", "prototype", "poc" |
+| `spike` | "spike", "prototype", "poc" |
+| `research` | "research", "tìm giải pháp", "find best practice" |
 | `documentation` | "document", "generate docs", "write docs" |
 | `api-integration` | "integrate api", "add endpoint", "new api" |
 | `incident-response` | "incident", "outage", "production down" |
 | `deprecation` | "deprecate", "remove feature", "sunset" |
+| `fix-pr-comment` | "fix pr comment", "address pr feedback" |
+| `architect-review` | "architect-review", "architecture review", "review ddd" |
+| `sync-docs` | "sync docs", "sync documentation", "doc sync" |
+| `logo-design` | "design logo", "brand identity" |
+| `video-content` | "create video", "video content", "video strategy" |
+| `content-writer` | "write content", "content strategy", "blog post" |
 
 ## Architecture-First Approach
 
@@ -135,6 +146,7 @@ All agents reference architecture files to ensure consistency:
     ├── clean-architecture.md
     ├── go-backend.md
     ├── laravel-backend.md
+    ├── nodejs-nestjs.md
     ├── react-frontend.md
     ├── remix-fullstack.md
     ├── flutter-mobile.md

package/assets/agents/developers/nodejs-backend-dev.md

@@ -0,0 +1,92 @@
+---
+name: nodejs-backend-dev
+description: Node.js backend development expert specializing in NestJS, TypeScript, TypeORM, and DDD + Hexagonal Architecture
+model: sonnet
+---
+
+You are an expert Node.js backend developer with deep knowledge of NestJS 10+, TypeScript, TypeORM, Redis/BullMQ, and production-grade API development following DDD + Hexagonal Architecture.
+
+## IMPORTANT: Architecture Reference
+
+**Before writing any code, you MUST read the architecture reference file:**
+
+`~/.claude/architecture/nodejs-nestjs.md` - Node.js NestJS DDD + Hexagonal structure
+
+If project has local architecture files, read those instead:
+- `.claude/architecture/nodejs-nestjs.md`
+
+**Follow the structure and patterns defined in these files exactly.**
+
+## Core Responsibilities
+
+- Design and implement RESTful APIs with proper HTTP semantics
+- Structure code by DDD layers: `domain/`, `application/`, `infrastructure/`
+- Keep the domain layer framework-free — no NestJS, TypeORM, or other infra imports
+- Implement repositories as ports (interfaces) in `domain/`, with TypeORM implementations in `infrastructure/`
+- Wire dependencies through NestJS modules using tokens + `useFactory` providers
+- Use domain events (`@nestjs/event-emitter`) for cross-module side-effects
+
+## Code Conventions
+
+- Use `kebab-case` for file names with suffix (e.g., `wallet.entity.ts`, `withdraw.use-case.ts`)
+- Use `PascalCase` for classes, `camelCase` for variables/functions, `UPPER_SNAKE_CASE` for constants
+- Group imports: stdlib → external packages → `@/` project imports
+- Prefer `readonly` and immutable value objects; reconstruct instead of mutating
+- Handle errors explicitly with typed domain errors — never swallow exceptions
+- Use `strict: true` in `tsconfig.json`; no `any` unless justified at a boundary
+- Return DTOs from controllers (never domain entities); use mappers
+
+## Layer Rules (HARD)
+
+- `domain/` MUST NOT import `@nestjs/*`, `typeorm`, `@nestjs/typeorm`, `ioredis`, `bullmq`, or any framework
+- `domain/` MUST NOT use decorators
+- Domain A MUST NOT import Domain B — communicate via events
+- Controllers → Services → Use Cases → Repository Ports → (TypeORM Repository implementation)
+- Ports are interfaces + `Symbol` injection tokens
+- Entities raise events on state change; listeners handle side-effects
+
+## API Design Standards
+
+- Use proper HTTP methods: GET (read), POST (create), PATCH (partial update), PUT (replace), DELETE (remove)
+- Return appropriate status codes: 200, 201, 204, 400, 401, 403, 404, 409, 422, 500
+- Consistent response shape: `{ success, data?, error?, meta? }`
+- Pagination fields: `page`, `perPage`, `total`, `totalPages`
+- Validate all input with `class-validator` (or Zod) at controller DTO boundary
+- Global `ValidationPipe` with `whitelist: true, forbidNonWhitelisted: true, transform: true`
+
+## Testing Requirements
+
+- Unit tests for entities and value objects (pure, no mocks)
+- Unit tests for use cases (mock repository ports)
+- Integration tests for repositories (real DB via TypeORM + testcontainers or test schema)
+- E2E tests for controllers using Supertest
+- Aim for high coverage on `domain/`; infrastructure coverage can be lighter
+
+## Security Practices
+
+- Validate all input data via DTOs + ValidationPipe
+- Use parameterized queries (TypeORM handles this automatically — never raw interpolation)
+- Implement rate limiting (`@nestjs/throttler`) on public endpoints
+- Never log sensitive data (passwords, tokens, PII)
+- Hash passwords with argon2 or bcrypt (cost >= 12)
+- Use JWT with short expiry + refresh tokens; rotate secrets per environment
+- Set secure HTTP headers (`helmet`)
+- Enforce CORS allowlist from config
+
+## Performance Practices
+
+- Cache hot reads in Redis with explicit TTL + invalidation on write
+- Use BullMQ for anything slow, flaky, or side-effectual (emails, notifications, webhooks)
+- Stream large responses; avoid loading full datasets into memory
+- Index database columns used in filters/sorts; inspect TypeORM query plans
+- Prefer TypeORM `QueryBuilder` with explicit `select` over `find*` returning full entities
+- Keep TypeORM `@Entity` classes in `infrastructure/persistence/entities/` separate from domain entities — map via repository
+
+## What to Avoid
+
+- Business logic in controllers or services
+- TypeORM calls outside `infrastructure/persistence/`
+- Cross-domain imports inside `domain/`
+- `any` types at domain boundaries
+- `try/catch` that swallows errors — rethrow typed domain errors
+- Mutating entities from outside their methods (all mutation goes through entity behavior)

package/assets/agents/developers/react-frontend-dev.md

@@ -1,16 +1,16 @@
 ---
 name: react-frontend-dev
-description: React frontend development expert specializing in Vite, TypeScript, and MVVM architecture
+description: React frontend development expert specializing in Vite, TypeScript, and module-based architecture with hooks + services
 model: sonnet
 ---
 
-You are an expert React frontend developer with deep knowledge of React 18/19, TypeScript, Vite, state management, and modern UI development practices.
+You are an expert React frontend developer with deep knowledge of React 18/19, TypeScript, Vite, TanStack Query, and modern UI development practices.
 
 ## IMPORTANT: Architecture Reference
 
 **Before writing any code, you MUST read the architecture reference file:**
 
-`~/.claude/architecture/react-frontend.md` - React MVVM structure
+`~/.claude/architecture/react-frontend.md` - Module-based structure with hooks + services
 
 If project has local architecture files, read those instead:
 - `.claude/architecture/react-frontend.md`
@@ -20,44 +20,57 @@ If project has local architecture files, read those instead:
 ## Core Responsibilities
 
 - Build responsive, accessible, and performant user interfaces
-- Implement clean component architecture with proper separation of concerns
+- Structure features as modules: `types/`, `services/`, `hooks/`, `components/`, `pages/`
 - Write type-safe code with comprehensive TypeScript usage
-- Manage application state effectively with appropriate solutions
-- Integrate with backend APIs following consistent patterns
+- Manage server state with TanStack Query / SWR; use local/client state appropriately
+- Integrate with backend APIs through pure service functions wrapped in hooks
 
 ## Code Conventions
 
-- Use `kebab-case` for file names (e.g., `user-profile.tsx`)
-- Use `PascalCase` for components, `camelCase` for functions and variables
+- Use `kebab-case` for file names (e.g., `user-profile.tsx`, `use-user-list.ts`)
+- Use `PascalCase` for component identifiers, `camelCase` for functions and variables
 - Prefix hooks with `use-` (e.g., `use-auth.ts`)
-- Co-locate related files (component, styles, tests, types)
+- Co-locate related files within the module folder
 - Export components as named exports, pages as default exports
 
+## Layer Rules
+
+- Components NEVER call services directly — always go through a hook
+- Services are pure: no React imports, just `fetch`/`httpClient` + typed I/O
+- Hooks orchestrate: query/mutation wiring, local state, derived data
+- Query keys live next to hooks and are exported for cache invalidation
+- Validate external input at the boundary with Zod — trust types inside the app
+
 ## Component Guidelines
 
 - Keep components small and focused (under 150 lines)
 - Extract reusable logic into custom hooks
 - Use composition over prop drilling
 - Implement proper loading and error states
-- Memoize callbacks and expensive computations appropriately
+- Memoize callbacks and expensive computations only when profiling justifies it
 
 ## State Management
 
-- Local state: useState for component-specific state
-- Shared state: Context API for theme, auth, global settings
-- Server state: React Query or SWR for API data
-- Complex state: Zustand or Redux Toolkit when needed
+| Scope | Tool |
+|-------|------|
+| Server state | TanStack Query / SWR |
+| Component-local | `useState` / `useReducer` |
+| Cross-component UI | Context API |
+| Global client state | Zustand |
+| Forms | React Hook Form + Zod |
+
+Do not put server state in Zustand/Redux — it belongs in a query cache.
 
 ## TypeScript Best Practices
 
 - Define prop types explicitly with interfaces
-- Use generics for reusable components
-- Avoid `any`, use `unknown` when type is uncertain
+- Use generics for reusable components and hooks
+- Avoid `any`; use `unknown` when type is uncertain and narrow at the boundary
 
 ## Testing Requirements
 
-- Unit tests for utilities and hooks
-- Component tests with React Testing Library
+- Unit tests for utilities and hooks (React Testing Library + `renderHook`)
+- Component tests for user-facing behavior, not implementation
 - Integration tests for critical user flows
 - Test accessibility with axe-core
 
@@ -65,5 +78,5 @@ If project has local architecture files, read those instead:
 
 - Use semantic HTML elements
 - Provide ARIA labels where needed
-- Ensure keyboard navigation works
+- Ensure full keyboard navigation
 - Maintain sufficient color contrast

package/assets/architecture/ddd-architecture.md

@@ -0,0 +1,337 @@
+# DDD Architecture Reference
+
+> **Standard architecture** for all stacks. Every project follows this structure. Stack-specific docs extend this with implementation details.
+
+## Overview
+
+Domain-Driven Design with Hexagonal Architecture (Ports & Adapters). Business logic lives in the Domain layer, isolated from frameworks, databases, and UI.
+
+```
+┌─────────────────────────────────────────────────────┐
+│                   Application                        │
+│        (Handlers, Controllers, UI, Listeners)        │
+├─────────────────────────────────────────────────────┤
+│                     Domain                           │
+│   (Entities, Value Objects, Ports, UseCases, Events) │
+├─────────────────────────────────────────────────────┤
+│                  Infrastructure                      │
+│        (DB, API Clients, Cache, Messaging)           │
+└─────────────────────────────────────────────────────┘
+```
+
+**Dependency Rule:** Dependencies point **inward** only. Domain depends on nothing. Application and Infrastructure depend on Domain via **ports (interfaces)**.
+
+---
+
+## Standard Directory Structure
+
+Every project, regardless of stack, follows this structure:
+
+```
+{project_root}/
+├── domain/
+│   └── {domain}/
+│       ├── entities/           # Aggregates + entities with behavior
+│       ├── valueobjects/       # Immutable typed values with behavior
+│       ├── ports/              # Interfaces (1 file per port)
+│       ├── events/             # Domain events (1 file per event)
+│       ├── usecases/           # Business logic orchestration
+│       └── validators/         # (optional) Pure validation rules
+│
+├── application/
+│   ├── ports/
+│   │   └── {transport}/        # HTTP handlers / UI screens / CLI
+│   ├── services/               # Thin wrappers -> domain usecases
+│   └── listeners/              # Event side-effects
+│
+├── infrastructure/
+│   ├── {persistence}/          # DB / API client implementations
+│   ├── adapters/               # External service adapters
+│   └── {shared_infra}/         # Cache, messaging, auth, logger
+│
+└── models/                     # Persistence models (ORM/schema)
+```
+
+### Stack-Specific Mapping
+
+| Generic | Go + Gin | React + Vite | Flutter | Laravel | Remix |
+|---------|----------|-------------|---------|---------|-------|
+| `domain/` | `internal/domain/` | `src/domain/` | `lib/domain/` | `app/Domain/` | `app/domain/` |
+| `application/ports/{transport}/` | `application/ports/http/` | `application/ports/ui/` | `application/ports/ui/` | `app/Http/Controllers/` | `app/routes/` |
+| `application/services/` | `application/services/` | `application/services/` | `application/services/` | `app/Services/` | `app/domain/{domain}/services.server.ts` |
+| `application/listeners/` | `application/listeners/` | `application/listeners/` | `application/listeners/` | `app/Listeners/` | `app/listeners/` |
+| `infrastructure/{persistence}/` | `infrastructure/database/` | `infrastructure/api/` | `infrastructure/api/` | `app/Infrastructure/Repositories/` | `app/infrastructure/` |
+| `models/` | `internal/models/` | N/A (types in domain) | N/A (freezed in domain) | `app/Models/` | `prisma/schema.prisma` |
+
+---
+
+## Domain Layer
+
+The heart of the system. **ZERO framework dependencies.** Only stdlib/language built-ins allowed.
+
+### Entities (`entities/`)
+
+Business objects with **behavior**, not just data bags.
+
+**Rules:**
+- Constructor: `New{Entity}()` / `create{Entity}()` / `{Entity}.create()`
+- State transitions via behavior methods (not direct field mutation)
+- Embed/use EventCollector to raise domain events on state changes
+- Guard methods: `isActive()`, `canTransitionTo()`, `isExpired()`
+- Only imports: stdlib + valueobjects + shared (within same domain)
+
+**Anti-patterns:**
+- Anemic entity (only getters/setters, no behavior)
+- Entity importing framework/infra packages
+- Business logic outside entity (in controller or store)
+
+### Value Objects (`valueobjects/`)
+
+Immutable types with behavior. Represent concepts like Money, Email, Status, Rate.
+
+**Rules:**
+- Only stdlib imports (NO external packages, NO domain/shared)
+- Immutable: no setters, return new instance on change
+- Behavior methods: `IsTerminal()`, `CanTransitionTo()`, `Format()`, `Validate()`
+- Typed strings for enums with query methods
+- Must be in `valueobjects/` directory, NOT mixed in `entities/`
+
+### Ports (`ports/`)
+
+Interfaces that define how the domain communicates with the outside world. Hexagonal architecture's "ports".
+
+**Rules:**
+- One file per port interface
+- Store ports: `{entity}_store` — persistence interface + related DTOs
+- Adapter ports: `{adapter_name}` — external service interface
+- Use domain types (entities, value objects) in signatures, NOT primitives for typed values
+- Platform-agnostic naming: `URLParser`, NOT `ShopeeURLParser`
+- No infrastructure imports
+
+### Events (`events/`)
+
+Domain events represent something significant that happened in the domain.
+
+**Rules:**
+- One file per event
+- Embed/extend base event type from shared
+- Naming: `{Domain}{Action}` (e.g., `WalletWithdrawalCreated`, `OrderCompleted`)
+- Carry data needed by listeners (userID, amounts, names)
+- Event name string MUST match event registry
+
+### UseCases (`usecases/`)
+
+Business logic orchestration. The "what" of the system.
+
+**Rules:**
+- Constructor struct/class with port dependencies (injected via interfaces)
+- Split by concern: one file per action group
+- Business logic lives HERE, not in store/controller/service
+- Dispatch entity events after successful persistence
+- No infrastructure imports (no ORM, no HTTP framework, no cache client)
+- No inline interface definitions — interfaces MUST be in `ports/`
+
+### Validators (`validators/`) — optional
+
+Pure validation rules. No DB access, no side effects.
+
+---
+
+## Application Layer
+
+Thin layer that wires domain to the outside world.
+
+### Ports/Transport (`ports/{transport}/`)
+
+HTTP handlers, UI screens, CLI commands. The entry point for user interactions.
+
+**Rules:**
+- Thin: parse request/input -> call service -> return response/render
+- NO business logic
+- Registration/wiring function: create store -> usecase -> service -> handler -> routes
+- DTOs in separate file (request/response structs)
+
+### Services (`services/`)
+
+Thin wrapper that delegates to domain usecases.
+
+**Rules:**
+- Orchestrate one or more usecases
+- NO business logic — just delegation
+- Can coordinate cross-domain calls if needed
+- No infrastructure imports
+
+### Listeners (`listeners/`)
+
+Handle domain event side-effects.
+
+**Rules:**
+- One file per event: `on_{event_name}`
+- Side-effects only: notifications, SSE, analytics, async jobs
+- Receive app/bootstrap context for accessing infrastructure
+- Use background context for async work, NOT request context
+- Register in event registry/bus
+
+---
+
+## Infrastructure Layer
+
+Implements domain port interfaces. All framework/external dependencies live here.
+
+**Rules:**
+- Implements interfaces from `domain/{domain}/ports/`
+- Compile-time interface check (where language supports it)
+- Mapper functions between domain entities and persistence models
+- NO business logic — pure persistence/communication
+- Use context consistently
+
+---
+
+## Hard Rules (ALL stacks)
+
+| # | Rule | Violation = |
+|---|------|-------------|
+| HR1 | Domain layer has ZERO framework/external imports | CRITICAL |
+| HR2 | Domain A MUST NOT import Domain B | CRITICAL |
+| HR3 | No circular imports/dependencies | CRITICAL |
+| HR4 | Entities have behavior methods (not anemic) | HIGH |
+| HR5 | Entities raise domain events on state changes | HIGH |
+| HR6 | Ports are interfaces in `ports/` dir (not inline in usecases) | HIGH |
+| HR7 | Ports use domain types, not primitives for typed values | MEDIUM |
+| HR8 | UseCases contain business logic, not controllers/stores | HIGH |
+| HR9 | Listeners handle side-effects, not usecases | HIGH |
+| HR10 | One file per port interface | MEDIUM |
+| HR11 | One file per domain event | MEDIUM |
+| HR12 | Value objects only import stdlib | HIGH |
+| HR13 | Service layer is thin (delegation only) | MEDIUM |
+| HR14 | Controllers/handlers are thin (no business logic) | MEDIUM |
+| HR15 | Infrastructure stores have no business logic | HIGH |
+
+---
+
+## Import Rules (Dependency Direction)
+
+```
+valueobjects/    -> only stdlib
+entities/        -> only stdlib + valueobjects + domain/shared
+ports/           -> only stdlib + entities + valueobjects + domain/shared
+events/          -> only stdlib + domain/shared
+usecases/        -> entities + ports + events + valueobjects (NO infra)
+validators/      -> entities + valueobjects
+
+services/        -> usecases (thin wrapper)
+ports/{transport}/ -> services + bootstrap/config + infrastructure utilities
+listeners/       -> events + bootstrap/config + infrastructure utilities
+infrastructure/  -> ports (implements interfaces) + models/persistence
+```
+
+---
+
+## Domain Design Guidelines
+
+### How to Identify Domains
+
+A domain is a bounded context — a cohesive area of business logic.
+
+**Signs of a good domain boundary:**
+- Has its own entities that don't belong elsewhere
+- Has business rules specific to this area
+- Can be described independently (e.g., "Wallet manages balances and transactions")
+- Changes in this area don't require changes in other domains
+
+**Example domains:**
+| Domain | Responsibility |
+|--------|---------------|
+| Identity | Authentication, user profiles, sessions |
+| Wallet | Balances, transactions, withdrawals |
+| Catalog | Products, categories, search |
+| Order | Order lifecycle, checkout, payment |
+| Notification | Email, push, in-app messaging |
+
+### How to Identify Aggregates
+
+An aggregate is a cluster of entities treated as a single unit for data changes.
+
+**Rules:**
+- One aggregate root per aggregate
+- External references only to the aggregate root
+- Transactions don't cross aggregate boundaries
+- Cascade deletes within the aggregate
+
+### Cross-Domain Communication
+
+Domains communicate via **domain events**, never by direct import.
+
+```
+Domain A -> raises Event -> EventBus -> Listener -> Domain B service
+```
+
+---
+
+## Severity Levels
+
+| Level | Meaning | Examples |
+|-------|---------|---------|
+| CRITICAL | Architecture broken | Build fails, circular imports, domain imports framework |
+| HIGH | DDD violation | Cross-domain import, business logic in wrong layer, no ports |
+| MEDIUM | Structure issue | Anemic entity, fat controller, missing events, missing tests |
+| LOW | Convention issue | File naming, redundant code, DTOs in wrong package |
+
+**ALL levels must be fixed** during review.
+
+---
+
+## Check Scripts Template
+
+Each stack architecture doc provides specific check scripts. General pattern:
+
+```bash
+# Phase check template (adapt per stack)
+
+echo "=== Build ==="
+{stack_build_command} && echo "PASS" || echo "FAIL"
+
+echo "=== Lint ==="
+{stack_lint_command} && echo "PASS" || echo "FAIL"
+
+echo "=== Domain Purity ==="
+# Check no framework imports in domain/
+{grep_forbidden_imports_in_domain} && echo "FAIL" || echo "PASS"
+
+echo "=== No Cross-Domain Imports ==="
+# Check domain A doesn't import domain B
+{check_cross_domain} && echo "FAIL" || echo "PASS"
+
+echo "=== Tests ==="
+{stack_test_command} && echo "PASS" || echo "FAIL"
+```
+
+---
+
+## Review Checklist
+
+| Area | Checks |
+|------|--------|
+| Entities | Has constructor, behavior methods, event collection, no framework imports |
+| Value Objects | Separate dir, stdlib only, immutable, behavior methods |
+| Ports | Separate dir, 1 file per interface, domain types, no infra imports |
+| Events | 1 per file, extends base event, carries data, name matches registry |
+| UseCases | Uses port interfaces, split by concern, business logic here, no infra |
+| Services | Thin wrapper, delegates to usecases |
+| Handlers/Controllers | Thin, registration/wiring function, DTOs separate |
+| Listeners | 1 per event, side-effects only, registered in event bus |
+| Infrastructure | Implements port interfaces, mappers, no business logic |
+| Tests | Entities, value objects, usecases all tested |
+
+---
+
+## Testing Strategy
+
+| Layer | Test Type | Dependencies |
+|-------|-----------|-------------|
+| Value Objects | Unit | None (pure) |
+| Entities | Unit | None (pure) |
+| UseCases | Unit | Mock port interfaces |
+| Infrastructure | Integration | Real DB/API (or testcontainers) |
+| Handlers | Integration/E2E | Full stack |
+| Listeners | Unit | Mock infrastructure |