backend on top level

Author: Joern Wellniak

.github/workflows/build.yml

@@ -13,63 +13,61 @@ jobs:
   build-backend:
     runs-on: ubuntu-latest
     name: Build Backend
-    
+
     permissions:
       contents: read
-    
+
     steps:
     - uses: actions/checkout@v4
-    
+
     - name: Set up JDK 21
       uses: actions/setup-java@v4
       with:
         java-version: '21'
         distribution: 'temurin'
         cache: maven
-    
+
     - name: Build Backend with Maven
       run: |
-        cd backend
         mvn clean package -DskipTests
-    
+
     - name: Run Backend Tests
       run: |
-        cd backend
         mvn test
-    
+
     - name: Upload Backend Artifacts
       uses: actions/upload-artifact@v4
       with:
         name: backend-jar
         path: backend/target/*.jar
-  
+
   build-frontend:
     runs-on: ubuntu-latest
     name: Build Frontend
-    
+
     permissions:
       contents: read
-    
+
     steps:
     - uses: actions/checkout@v4
-    
+
     - name: Set up Node.js
       uses: actions/setup-node@v4
       with:
         node-version: '20'
         cache: 'npm'
         cache-dependency-path: frontend/package-lock.json
-    
+
     - name: Install Frontend Dependencies
       run: |
         cd frontend
         npm ci
-    
+
     - name: Build Frontend
       run: |
         cd frontend
         npm run build
-    
+
     - name: Upload Frontend Artifacts
       uses: actions/upload-artifact@v4
       with:

.gitignore

@@ -26,10 +26,10 @@ hs_err_pid*
 replay_pid*
 
 # Backend build artifacts
-backend/target/
-backend/.mvn/
-backend/mvnw
-backend/mvnw.cmd
+target/
+.mvn/
+mvnw
+mvnw.cmd
 
 # Frontend dependencies and build artifacts
 frontend/node_modules/

README.md

@@ -1,96 +1,162 @@
-# Skat
+# Skat Backend
 
-A mono-repo project with Java 21 Spring Boot backend and Angular 18 frontend.
+Spring Boot REST API backend for the Skat application.
 
-## Project Structure
+## Technology Stack
 
-```
-.
-├── backend/          # Spring Boot backend (Java 21)
-├── frontend/         # Angular 18 frontend
-└── .github/          # CI/CD workflows
-    └── workflows/
-        └── build.yml # Build pipeline
+- **Java**: 21
+- **Spring Boot**: 3.5.6
+- **Database**: PostgreSQL (production), H2 (development)
+- **Build Tool**: Maven
+
+## Prerequisites
+
+- Java 21 or higher
+- Maven 3.6 or higher
+- PostgreSQL (for production mode)
+
+## Getting Started
+
+### Running with H2 In-Memory Database (Development)
+
+The easiest way to start the application for development is using the H2 in-memory database:
+
+```bash
+mvn spring-boot:run -Dspring-boot.run.profiles=dev
 ```
 
-## Backend
+The application will start on `http://localhost:8080`
 
-### Technology Stack
-- Java 21
-- Spring Boot 3.4.2
-- PostgreSQL
-- Maven
+### Running with PostgreSQL (Production)
 
-### Build and Run
+1. Ensure PostgreSQL is running and create a database:
+   ```sql
+   CREATE DATABASE skatdb;
+   ```
+
+2. Update the database credentials in `src/main/resources/application.properties` if needed:
+   ```properties
+   spring.datasource.url=jdbc:postgresql://localhost:5432/skatdb
+   spring.datasource.username=postgres
+   spring.datasource.password=postgres
+   ```
+
+3. Start the application:
+   ```bash
+   mvn spring-boot:run
+   ```
+
+### Building the Application
+
+To build the application and create an executable JAR:
 
 ```bash
-cd backend
 mvn clean package
-mvn spring-boot:run
 ```
 
-The backend will start on `http://localhost:8080`
+The JAR file will be created in the `target/` directory.
 
-For development without PostgreSQL, you can use the H2 in-memory database:
+### Running the JAR
+
+After building, you can run the application using:
 
 ```bash
-cd backend
-mvn spring-boot:run -Dspring-boot.run.profiles=dev
-```
+# With H2 (development)
+java -jar target/backend-0.0.1-SNAPSHOT.jar --spring.profiles.active=dev
 
-### API Endpoints
+# With PostgreSQL (production)
+java -jar target/backend-0.0.1-SNAPSHOT.jar
+```
 
-- `GET /api/hello` - Returns "Hallo"
+## Running Tests
 
-### Database Configuration
+Execute the test suite:
 
-PostgreSQL configuration is in `backend/src/main/resources/application.properties`:
-- URL: `jdbc:postgresql://localhost:5432/skatdb`
-- Username: `postgres`
-- Password: `postgres`
+```bash
+mvn test
+```
 
-## Frontend
+## API Endpoints
 
-### Technology Stack
-- Angular 18
-- TypeScript
-- Node.js 20
+### Hello World Endpoint
 
-### Build and Run
+- **URL**: `/api/hello`
+- **Method**: `GET`
+- **Response**: Plain text "Hallo"
 
+Example:
 ```bash
-cd frontend
-npm install
-npm start
+curl http://localhost:8080/api/hello
 ```
 
-The frontend will start on `http://localhost:4200`
+## Configuration Profiles
 
-### Features
+### Development Profile (`dev`)
 
-- Calls the backend `/api/hello` endpoint
-- Displays the response without formatting
+Uses H2 in-memory database. Configuration file: `application-dev.properties`
 
-## Build Pipeline
+- Database: H2 in-memory
+- H2 Console: Enabled at `/h2-console`
+- SQL logging: Enabled
 
-The project includes a GitHub Actions workflow that:
-- Builds the backend with Maven
-- Runs backend tests
-- Builds the frontend with npm
-- Uploads build artifacts
+### Default Profile (Production)
+
+Uses PostgreSQL database. Configuration file: `application.properties`
+
+- Database: PostgreSQL
+- Connection pooling: HikariCP (default)
+
+## Project Structure
+
+```
+backend/
+├── src/
+│   ├── main/
+│   │   ├── java/
+│   │   │   └── com/skat/backend/
+│   │   │       ├── SkatBackendApplication.java    # Main application class
+│   │   │       └── controller/
+│   │   │           └── HelloWorldController.java  # REST controller
+│   │   └── resources/
+│   │       ├── application.properties              # Production config
+│   │       └── application-dev.properties          # Development config
+│   └── test/
+│       └── java/
+│           └── com/skat/backend/
+│               └── controller/
+│                   └── HelloWorldControllerTest.java  # Controller tests
+├── pom.xml                                         # Maven configuration
+└── README.md                                       # This file
+```
+
+## Troubleshooting
+
+### Port Already in Use
+
+If port 8080 is already in use, you can change it by adding to your run command:
+
+```bash
+mvn spring-boot:run -Dspring-boot.run.arguments=--server.port=8081
+```
+
+### Database Connection Issues
+
+- Verify PostgreSQL is running: `pg_isready`
+- Check PostgreSQL logs for connection errors
+- Verify database credentials in `application.properties`
 
 ## Development
 
-1. Start the backend:
-   ```bash
-   cd backend
-   mvn spring-boot:run
-   ```
+### Adding New Dependencies
 
-2. In a new terminal, start the frontend:
-   ```bash
-   cd frontend
-   npm start
-   ```
+Add dependencies to `pom.xml` and run:
+
+```bash
+mvn clean install
+```
+
+### Code Style
 
-3. Open your browser at `http://localhost:4200`
+The project follows standard Java coding conventions. Ensure your IDE is configured to use:
+- Tab size: 4 spaces
+- Charset: UTF-8