FileFlexManager Web NAS Development

Build a powerful, flexible mobile-first web file manager for Linux NAS systems using Domain-Driven Design architecture with Spring Boot 3 backend and Vue 3 frontend.

Project Overview

FileFlexManager is a web-based file management system targeting Linux NAS environments with:

Technology Stack

**Backend:**

**Frontend:**

Architecture Layers (DDD)

Follow strict Domain-Driven Design layer boundaries:

1. **Interfaces Layer** (`backend/interfaces/`)

- API controllers, DTOs, request/response models

- Global exception handling and advice

- DTO ↔ Domain mapping with MapStruct

- Structure: `api/`, `controller/`, `model/dto|req|resp|vo/`

2. **Application Layer** (`backend/application/`)

- Application services orchestrating domain logic

- DTOs and assemblers

- Event handlers and schedulers

- Configuration management

3. **Domain Layer** (`backend/domain/`)

- Core business logic and domain models

- Domain events and services

- Repository interfaces

- Business rules and invariants

4. **Infrastructure Layer** (`backend/infrastructure/`)

- Persistence implementation (MyBatis Plus)

- Domain ↔ PO/Entity mapping with MapStruct

- External system integrations

- Security configuration

- Task handlers

- Structure: `persistence/converter|entity|mapper|po|repository/`

Project Structure

```

backend/

├── domain/ # Core business logic

│ ├── event/

│ ├── model/

│ ├── repository/

│ ├── service/

│ └── utils/

├── application/ # Use cases and orchestration

│ ├── assembler/

│ ├── dto/

│ ├── event/

│ └── service/

├── infrastructure/ # Technical concerns

│ ├── persistence/

│ │ ├── converter/ # Domain ↔ PO mapping

│ │ ├── entity/

│ │ ├── mapper/ # MyBatis Plus mappers

│ │ ├── po/

│ │ └── repository/ # Repository implementations

│ ├── security/

│ └── task/

└── interfaces/ # API exposure

└── src/main/

├── java/.../interfaces/

│ ├── api/

│ │ ├── advice/ # Global exception handling

│ │ ├── assembler/ # DTO ↔ Domain mapping

│ │ └── controller/

│ └── model/

│ ├── dto/

│ ├── req/

│ ├── resp/

│ └── vo/

└── resources/

├── db.migration/

├── static/

└── application*.yml

frontend/

├── src/

│ ├── api/ # API service layer

│ ├── components/ # Reusable Vue components

│ ├── router/ # Vue Router config

│ ├── stores/ # Pinia state management

│ ├── utils/ # Helper functions

│ └── views/ # Page components

├── public/

└── config/

└── env/

```

Code Standards

Backend

1. **Exception Handling**

- Use global exception handler in `interfaces/api/advice/`

- All API responses wrapped in `BaseResponse`

- Domain-specific exceptions in domain layer

2. **Data Models**

- **DTO**: Data Transfer Objects in interfaces layer

- **Domain Models**: Business entities in domain layer

- **PO**: Persistence Objects in infrastructure layer

- Use MapStruct for all conversions between layers

3. **Data Access**

- Repository pattern with interfaces in domain layer

- Implementations in infrastructure layer using MyBatis Plus

- No direct database access from application or domain layers

4. **Domain Events**

- Emit events for significant domain state changes

- Handle events in application layer

- Keep domain layer event-agnostic

Frontend

1. **API Handling**

- All API calls go through unified configuration in `config.ts`

- Use Composition API for request logic

- Handle `BaseResponse` uniformly

- Type all API responses with TypeScript interfaces

2. **Component Structure**

- Mobile-first responsive design using Vant UI

- Composition API with `<script setup>`

- TypeScript for all components

- Props and emits with type definitions

3. **Import Paths**

- Use path aliases only (configured in TypeScript/Vite)

- Example: `@/api/`, `@/components/`, `@/utils/`

Testing Standards

Unit Tests

**Location**: `src/test/java/{package}/*Test.java`

**Requirements**:

**Structure**:

```java

@Test

void shouldPerformActionWhenCondition() {

// Given

// When

// Then

}

```

Integration Tests

**Location**: `backend/interfaces/src/test/java/*IntegrationTest.java`

**Requirements**:

Deployment

Development Workflow

1. **Define Domain Models**: Start with domain layer entities and business logic

2. **Create Repository Interfaces**: Define data access contracts in domain layer

3. **Implement Infrastructure**: Build persistence with MyBatis Plus and PO entities

4. **MapStruct Mappings**: Create converters for Domain ↔ PO in infrastructure

5. **Application Services**: Orchestrate use cases in application layer

6. **API Controllers**: Expose endpoints in interfaces layer with DTO ↔ Domain mapping

7. **Frontend Integration**: Build Vue components consuming unified API

8. **Write Tests**: Unit tests for domain/application, integration tests for APIs

Key Principles