@wipal/agent-team 1.0.3 → 1.1.0

package/.claude/skills/domain/architecture/mermaid-diagrams/references/sequence-diagrams.md

@@ -0,0 +1,394 @@
+# Sequence Diagrams
+
+Sequence diagrams show interactions between participants over time. They're ideal for API flows, authentication sequences, and system component interactions.
+
+## Basic Syntax
+
+```mermaid
+sequenceDiagram
+    participant A
+    participant B
+    A->>B: Message
+```
+
+## Participants and Actors
+
+```mermaid
+sequenceDiagram
+    actor User
+    participant Frontend
+    participant API
+    participant Database
+    
+    User->>Frontend: Click button
+    Frontend->>API: POST /data
+```
+
+**Difference:**
+- `participant` - System components (services, classes, databases)
+- `actor` - External entities (users, external systems)
+
+## Message Types
+
+### Solid Arrow (Synchronous)
+```mermaid
+sequenceDiagram
+    Client->>Server: Request
+    Server-->>Client: Response
+```
+
+- `->>`  Solid arrow (request)
+- `-->>`  Dotted arrow (response/return)
+
+### Open Arrow (Asynchronous)
+```mermaid
+sequenceDiagram
+    Client-)Server: Async message
+    Server--)Client: Async response
+```
+
+- `-)` Solid open arrow
+- `--)` Dotted open arrow
+
+### Cross/X (Delete)
+```mermaid
+sequenceDiagram
+    Client-xServer: Delete
+```
+
+## Activations
+
+Show when a participant is actively processing:
+
+```mermaid
+sequenceDiagram
+    Client->>+Server: Request
+    Server->>+Database: Query
+    Database-->>-Server: Data
+    Server-->>-Client: Response
+```
+
+- `+` after arrow activates
+- `-` before arrow deactivates
+
+## Alt/Else (Conditional Logic)
+
+```mermaid
+sequenceDiagram
+    User->>API: POST /login
+    API->>Database: Query user
+    Database-->>API: User data
+    
+    alt Valid credentials
+        API-->>User: 200 OK + Token
+    else Invalid credentials
+        API-->>User: 401 Unauthorized
+    else Account locked
+        API-->>User: 403 Forbidden
+    end
+```
+
+## Opt (Optional)
+
+```mermaid
+sequenceDiagram
+    User->>API: POST /order
+    API->>PaymentService: Process payment
+    
+    opt Payment successful
+        API->>EmailService: Send confirmation
+    end
+    
+    API-->>User: Order result
+```
+
+## Par (Parallel)
+
+Show concurrent operations:
+
+```mermaid
+sequenceDiagram
+    API->>Service: Process order
+    
+    par Send email
+        Service->>EmailService: Send confirmation
+    and Update inventory
+        Service->>InventoryService: Reduce stock
+    and Log event
+        Service->>LogService: Log order
+    end
+    
+    Service-->>API: Complete
+```
+
+## Loop
+
+```mermaid
+sequenceDiagram
+    Client->>Server: Request batch
+    
+    loop For each item
+        Server->>Database: Process item
+        Database-->>Server: Result
+    end
+    
+    Server-->>Client: All results
+```
+
+**Loop with condition:**
+```mermaid
+sequenceDiagram
+    loop Every 5 seconds
+        Monitor->>API: Health check
+        API-->>Monitor: Status
+    end
+```
+
+## Break (Early Exit)
+
+```mermaid
+sequenceDiagram
+    User->>API: Submit form
+    API->>Validator: Validate input
+    
+    break Input invalid
+        API-->>User: 400 Bad Request
+    end
+    
+    API->>Database: Save data
+    Database-->>API: Success
+    API-->>User: 200 OK
+```
+
+## Notes
+
+### Note over single participant
+```mermaid
+sequenceDiagram
+    User->>API: Request
+    Note over API: Validates JWT token
+    API-->>User: Response
+```
+
+### Note spanning participants
+```mermaid
+sequenceDiagram
+    Frontend->>API: Request
+    Note over Frontend,API: HTTPS encrypted
+    API-->>Frontend: Response
+```
+
+### Right/Left notes
+```mermaid
+sequenceDiagram
+    User->>System: Action
+    Note right of System: Logs to database
+    System-->>User: Response
+    Note left of User: Updates UI
+```
+
+## Sequence Numbers
+
+Automatically number messages:
+
+```mermaid
+sequenceDiagram
+    autonumber
+    
+    User->>Frontend: Login
+    Frontend->>API: Authenticate
+    API->>Database: Verify credentials
+    Database-->>API: User data
+    API-->>Frontend: JWT token
+    Frontend-->>User: Success
+```
+
+## Links and Tooltips
+
+Add clickable links:
+
+```mermaid
+sequenceDiagram
+    participant A as Service A
+    link A: Dashboard @ https://dashboard.example.com
+    link A: API Docs @ https://docs.example.com
+    
+    A->>B: Message
+```
+
+## Comprehensive Example: User Authentication Flow
+
+```mermaid
+sequenceDiagram
+    autonumber
+    actor User
+    participant Frontend
+    participant AuthAPI
+    participant Database
+    participant Redis
+    participant EmailService
+    
+    User->>+Frontend: Enter credentials
+    Frontend->>+AuthAPI: POST /auth/login
+    
+    AuthAPI->>+Database: Query user by email
+    Database-->>-AuthAPI: User record
+    
+    alt User not found
+        AuthAPI-->>Frontend: 404 User not found
+        Frontend-->>User: Show error
+    else User found
+        AuthAPI->>AuthAPI: Verify password hash
+        
+        alt Invalid password
+            AuthAPI->>Database: Increment failed attempts
+            
+            opt Failed attempts > 5
+                AuthAPI->>Database: Lock account
+                AuthAPI->>EmailService: Send security alert
+            end
+            
+            AuthAPI-->>Frontend: 401 Invalid credentials
+            Frontend-->>User: Show error
+        else Valid password
+            AuthAPI->>AuthAPI: Generate JWT token
+            AuthAPI->>+Redis: Store session
+            Redis-->>-AuthAPI: Confirm
+            
+            par Update login metadata
+                AuthAPI->>Database: Update last_login
+            and Track analytics
+                AuthAPI->>Database: Log login event
+            end
+            
+            AuthAPI-->>-Frontend: 200 OK + JWT token
+            Frontend->>Frontend: Store token in localStorage
+            Frontend-->>-User: Redirect to dashboard
+            
+            opt First login
+                EmailService->>User: Welcome email
+            end
+        end
+    end
+```
+
+## API Request/Response Example
+
+```mermaid
+sequenceDiagram
+    autonumber
+    participant Client
+    participant Gateway
+    participant AuthService
+    participant UserService
+    participant Database
+    
+    Client->>+Gateway: GET /api/users/123
+    Note over Gateway: Rate limiting check
+    
+    Gateway->>+AuthService: Validate JWT
+    AuthService->>AuthService: Verify signature
+    
+    alt Token invalid or expired
+        AuthService-->>Gateway: 401 Unauthorized
+        Gateway-->>Client: 401 Unauthorized
+    else Token valid
+        AuthService-->>-Gateway: User context
+        
+        Gateway->>+UserService: GET /users/123
+        UserService->>+Database: SELECT * FROM users WHERE id=123
+        Database-->>-UserService: User record
+        
+        alt User not found
+            UserService-->>Gateway: 404 Not Found
+            Gateway-->>Client: 404 Not Found
+        else User found
+            UserService-->>-Gateway: 200 OK + User data
+            Gateway-->>-Client: 200 OK + User data
+        end
+    end
+```
+
+## Microservices Communication
+
+```mermaid
+sequenceDiagram
+    actor User
+    participant Gateway
+    participant OrderService
+    participant PaymentService
+    participant InventoryService
+    participant NotificationService
+    participant MessageQueue
+    
+    User->>+Gateway: POST /orders
+    Gateway->>+OrderService: Create order
+    
+    OrderService->>+InventoryService: Check stock
+    InventoryService-->>-OrderService: Stock available
+    
+    break Insufficient stock
+        OrderService-->>Gateway: 400 Out of stock
+        Gateway-->>User: Error message
+    end
+    
+    OrderService->>OrderService: Reserve order
+    OrderService->>+PaymentService: Charge customer
+    
+    alt Payment successful
+        PaymentService-->>-OrderService: Payment confirmed
+        OrderService->>MessageQueue: Publish OrderConfirmed event
+        
+        par Async processing
+            MessageQueue->>InventoryService: Reduce stock
+        and
+            MessageQueue->>NotificationService: Send confirmation
+            NotificationService->>User: Email confirmation
+        end
+        
+        OrderService-->>-Gateway: 201 Created
+        Gateway-->>User: Order confirmed
+    else Payment failed
+        PaymentService-->>OrderService: Payment declined
+        OrderService->>OrderService: Release reservation
+        OrderService-->>Gateway: 402 Payment Required
+        Gateway-->>User: Payment failed
+    end
+```
+
+## Best Practices
+
+1. **Order participants logically** - Typically: User → Frontend → Backend → Database
+2. **Use activations** - Shows when components are actively processing
+3. **Group related logic** - Use alt/opt/par to organize conditional flows
+4. **Add descriptive notes** - Explain complex logic or important details
+5. **Keep diagrams focused** - One scenario per diagram
+6. **Number messages** - Use autonumber for complex flows
+7. **Show error paths** - Document failure scenarios with alt/else
+8. **Indicate async operations** - Use open arrows for fire-and-forget messages
+
+## Common Use Cases
+
+### Authentication
+- Login flows
+- OAuth/SSO flows
+- Token refresh
+- Password reset
+
+### API Operations
+- CRUD operations
+- Search and filtering
+- Batch processing
+- Webhook handling
+
+### System Integration
+- Microservice communication
+- Third-party API calls
+- Message queue processing
+- Event-driven architecture
+
+### Business Processes
+- Order fulfillment
+- Payment processing
+- Approval workflows
+- Notification chains

package/.claude/skills/domain/backend/testing-be/SKILL.md

@@ -1,41 +1,44 @@
 ---
 name: testing-be
 description: |
-  Backend testing patterns with Jest, Vitest, and integration testing. Use when:
-  writing unit tests, integration tests, API tests, or when user mentions "test",
-  "unit test", "integration test", "API test", "mock", "fixture". Test behavior,
-  not implementation.
-version: 1.0.0
+  Backend testing from developer perspective: Unit Tests, Integration Tests,
+  Functional Tests, API Tests. Use when writing tests for your own code.
+  NOT for E2E/QA testing (that's QA domain). Test behavior, not implementation.
+version: 1.1.0
 category: backend
 tags:
   - testing
   - unit-test
   - integration-test
+  - functional-test
   - api-test
 depends_on:
   - code-review
   - api-design
 recommends: []
-used_by: []
+used_by:
+  - dev-be
 ---
 
-# Skill: Testing BE
+# Skill: Testing BE (Developer Perspective)
 
 ## Core Principle
-**Test behavior, not implementation.** Good tests survive refactors. They document expected behavior.
+**Test behavior, not implementation.** As a developer, you test YOUR code to ensure it works correctly. E2E testing is QA's responsibility.
 
-## Testing Pyramid
+## Testing Pyramid (Developer Focus)
 
 ```
-         ▲
-        /E2E\         Few, slow
-       /─────\
-      /  API  \       Some, medium
-     /─────────\
-    /  Unit     \     Many, fast
-   /─────────────\
+        ▲
+       /API\          Some, medium speed (Integration)
+      /─────\
+     /Functional\     Many, fast
+    /────────────\
+   /    Unit      \   Many, very fast
+  /────────────────\
 ```
 
+**Note:** E2E testing is NOT included - that's QA/Tester domain, not developer responsibility.
+
 ## Hard Rules
 
 1. **NEVER test implementation** - Test behavior/output
@@ -43,9 +46,12 @@ used_by: []
 3. **ALWAYS clean up resources** - Close connections, delete data
 4. **ALWAYS use descriptive names** - `should_..._when_...`
 5. **ALWAYS mock external services** - No real API calls
+6. **NO E2E tests** - That's QA domain, not dev responsibility
 
 ## Unit Tests
 
+Test individual functions and classes in isolation.
+
 ```typescript
 // userService.test.ts
 import { describe, it, expect, vi, beforeEach } from 'vitest';
@@ -87,6 +93,8 @@ describe('UserService', () => {
 
 ## Integration Tests
 
+Test how multiple components work together.
+
 ```typescript
 // api.test.ts
 import { describe, it, expect, beforeAll, afterAll } from 'vitest';
@@ -94,7 +102,7 @@ import { FastifyInstance } from 'fastify';
 import { buildApp } from './app';
 import { prisma } from './db';
 
-describe('User API', () => {
+describe('User API Integration', () => {
   let app: FastifyInstance;
 
   beforeAll(async () => {
@@ -128,6 +136,100 @@ describe('User API', () => {
 });
 ```
 
+## Functional Tests
+
+Test complete features and business logic.
+
+```typescript
+// orderService.functional.test.ts
+import { describe, it, expect, beforeEach } from 'vitest';
+import { OrderService } from './orderService';
+import { InventoryService } from './inventoryService';
+import { PaymentService } from './paymentService';
+
+describe('OrderService Functional Tests', () => {
+  let orderService: OrderService;
+  let inventoryService: InventoryService;
+  let paymentService: PaymentService;
+
+  beforeEach(() => {
+    inventoryService = new InventoryService();
+    paymentService = new PaymentService();
+    orderService = new OrderService(inventoryService, paymentService);
+  });
+
+  it('should create order when inventory available', async () => {
+    const orderData = {
+      productId: 'prod-1',
+      quantity: 2,
+      userId: 'user-1',
+    };
+
+    const result = await orderService.createOrder(orderData);
+
+    expect(result.status).toBe('confirmed');
+    expect(result.quantity).toBe(2);
+  });
+
+  it('should fail when insufficient inventory', async () => {
+    const orderData = {
+      productId: 'prod-out-of-stock',
+      quantity: 100,
+      userId: 'user-1',
+    };
+
+    await expect(orderService.createOrder(orderData)).rejects.toThrow('Insufficient inventory');
+  });
+
+  it('should handle payment failure gracefully', async () => {
+    const orderData = {
+      productId: 'prod-1',
+      quantity: 1,
+      userId: 'user-payment-fail',
+    };
+
+    await expect(orderService.createOrder(orderData)).rejects.toThrow('Payment failed');
+  });
+});
+```
+
+## API Tests
+
+Test HTTP endpoints directly.
+
+```typescript
+// auth.api.test.ts
+import { describe, it, expect } from 'vitest';
+import request from 'supertest';
+import { app } from './app';
+
+describe('Auth API', () => {
+  it('POST /auth/login should return token', async () => {
+    const response = await request(app)
+      .post('/auth/login')
+      .send({ email: 'test@example.com', password: 'password123' });
+
+    expect(response.status).toBe(200);
+    expect(response.body).toHaveProperty('token');
+  });
+
+  it('POST /auth/login should reject invalid credentials', async () => {
+    const response = await request(app)
+      .post('/auth/login')
+      .send({ email: 'test@example.com', password: 'wrong' });
+
+    expect(response.status).toBe(401);
+    expect(response.body).toHaveProperty('error');
+  });
+
+  it('GET /protected should require auth', async () => {
+    const response = await request(app).get('/protected');
+
+    expect(response.status).toBe(401);
+  });
+});
+```
+
 ## Test Database
 
 ```typescript
@@ -167,6 +269,7 @@ afterAll(async () => {
 | Real external APIs | Mock them |
 | Slow tests | Use in-memory DB |
 | Flaky tests | Fix or delete |
+| Writing E2E tests | That's QA domain |
 
 ## Mocking Patterns
 
@@ -201,3 +304,4 @@ it('should_create_order_when_valid_request')
 - [ ] Descriptive test names
 - [ ] Fast test execution
 - [ ] CI integration
+- [ ] NO E2E tests (that's QA domain)