FEATURE (monitorings): Get rid of monitoring

Fix/build for arm

.github/workflows/ci-release.yml

@@ -0,0 +1,457 @@
+name: CI and Release
+
+on:
+  push:
+    branches: ["**"]
+  pull_request:
+    branches: ["**"]
+  workflow_dispatch:
+
+jobs:
+  lint-backend:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v4
+
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: "1.23.3"
+
+      - name: Cache Go modules
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/go/pkg/mod
+            ~/.cache/go-build
+          key: ${{ runner.os }}-go-${{ hashFiles('backend/go.sum') }}
+          restore-keys: |
+            ${{ runner.os }}-go-
+
+      - name: Install golangci-lint
+        run: |
+          curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b $(go env GOPATH)/bin v1.60.3
+          echo "$(go env GOPATH)/bin" >> $GITHUB_PATH
+
+      - name: Install swag for swagger generation
+        run: go install github.com/swaggo/swag/cmd/swag@v1.16.4
+
+      - name: Generate swagger docs
+        run: |
+          cd backend
+          swag init -d . -g cmd/main.go -o swagger
+
+      - name: Run golangci-lint
+        run: |
+          cd backend
+          golangci-lint run
+
+      - name: Verify go mod tidy
+        run: |
+          cd backend
+          go mod tidy
+          git diff --exit-code go.mod go.sum || (echo "go mod tidy made changes, please run 'go mod tidy' and commit the changes" && exit 1)
+
+  lint-frontend:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out code
+        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 dependencies
+        run: |
+          cd frontend
+          npm ci
+
+      - name: Check if prettier was run
+        run: |
+          cd frontend
+          npm run format
+          git diff --exit-code || (echo "Prettier made changes, please run 'npm run format' and commit the changes" && exit 1)
+
+      - name: Check if linter was run
+        run: |
+          cd frontend
+          npm run lint
+
+  test-backend:
+    runs-on: ubuntu-latest
+    needs: [lint-backend]
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v4
+
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: "1.23.3"
+
+      - name: Cache Go modules
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/go/pkg/mod
+            ~/.cache/go-build
+          key: ${{ runner.os }}-go-${{ hashFiles('backend/go.sum') }}
+          restore-keys: |
+            ${{ runner.os }}-go-
+
+      - name: Create .env file for testing
+        run: |
+          cd backend
+          cat > .env << EOF
+          # docker-compose.yml
+          DEV_DB_NAME=postgresus
+          DEV_DB_USERNAME=postgres
+          DEV_DB_PASSWORD=Q1234567
+          #app
+          ENV_MODE=development
+          # db
+          DATABASE_DSN=host=localhost user=postgres password=Q1234567 dbname=postgresus port=5437 sslmode=disable
+          DATABASE_URL=postgres://postgres:Q1234567@localhost:5437/postgresus?sslmode=disable
+          # migrations
+          GOOSE_DRIVER=postgres
+          GOOSE_DBSTRING=postgres://postgres:Q1234567@localhost:5437/postgresus?sslmode=disable
+          GOOSE_MIGRATION_DIR=./migrations
+          # testing
+          # to get Google Drive env variables: add storage in UI and copy data from added storage here 
+          TEST_GOOGLE_DRIVE_CLIENT_ID=${{ secrets.TEST_GOOGLE_DRIVE_CLIENT_ID }}
+          TEST_GOOGLE_DRIVE_CLIENT_SECRET=${{ secrets.TEST_GOOGLE_DRIVE_CLIENT_SECRET }}
+          TEST_GOOGLE_DRIVE_TOKEN_JSON=${{ secrets.TEST_GOOGLE_DRIVE_TOKEN_JSON }}
+          # testing DBs
+          TEST_POSTGRES_13_PORT=5001
+          TEST_POSTGRES_14_PORT=5002
+          TEST_POSTGRES_15_PORT=5003
+          TEST_POSTGRES_16_PORT=5004
+          TEST_POSTGRES_17_PORT=5005
+          TEST_POSTGRES_18_PORT=5006
+          # testing S3
+          TEST_MINIO_PORT=9000
+          TEST_MINIO_CONSOLE_PORT=9001
+          # testing NAS
+          TEST_NAS_PORT=7006
+          EOF
+
+      - name: Start test containers
+        run: |
+          cd backend
+          docker compose -f docker-compose.yml.example up -d
+
+      - name: Wait for containers to be ready
+        run: |
+          # Wait for main dev database
+          timeout 60 bash -c 'until docker exec dev-db pg_isready -h localhost -p 5437 -U postgres; do sleep 2; done'
+
+          # Wait for test databases
+          timeout 60 bash -c 'until nc -z localhost 5001; do sleep 2; done'
+          timeout 60 bash -c 'until nc -z localhost 5002; do sleep 2; done'
+          timeout 60 bash -c 'until nc -z localhost 5003; do sleep 2; done'
+          timeout 60 bash -c 'until nc -z localhost 5004; do sleep 2; done'
+          timeout 60 bash -c 'until nc -z localhost 5005; do sleep 2; done'
+
+          # Wait for MinIO
+          timeout 60 bash -c 'until nc -z localhost 9000; do sleep 2; done'
+
+      - name: Create data and temp directories
+        run: |
+          # Create directories that are used for backups and restore
+          # These paths match what's configured in config.go
+          mkdir -p postgresus-data/backups
+          mkdir -p postgresus-data/temp
+
+      - name: Install PostgreSQL client tools
+        run: |
+          chmod +x backend/tools/download_linux.sh
+          cd backend/tools
+          ./download_linux.sh
+
+      - name: Run database migrations
+        run: |
+          cd backend
+          go install github.com/pressly/goose/v3/cmd/goose@latest
+          goose up
+
+      - name: Run Go tests
+        run: |
+          cd backend
+          go test ./internal/...
+
+      - name: Stop test containers
+        if: always()
+        run: |
+          cd backend
+          docker compose -f docker-compose.yml.example down -v
+
+  determine-version:
+    runs-on: ubuntu-latest
+    needs: [test-backend, lint-frontend]
+    if: ${{ github.ref == 'refs/heads/main' && !contains(github.event.head_commit.message, '[skip-release]') }}
+    outputs:
+      should_release: ${{ steps.version_bump.outputs.should_release }}
+      new_version: ${{ steps.version_bump.outputs.new_version }}
+      bump_type: ${{ steps.version_bump.outputs.bump_type }}
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+
+      - name: Install semver
+        run: npm install -g semver
+
+      - name: Get current version
+        id: current_version
+        run: |
+          LATEST_TAG=$(git describe --tags --abbrev=0 2>/dev/null || echo "v0.0.0")
+          echo "current_version=${LATEST_TAG#v}" >> $GITHUB_OUTPUT
+          echo "Current version: ${LATEST_TAG#v}"
+
+      - name: Analyze commits and determine version bump
+        id: version_bump
+        run: |
+          CURRENT_VERSION="${{ steps.current_version.outputs.current_version }}"
+          LATEST_TAG=$(git describe --tags --abbrev=0 2>/dev/null || echo "v0.0.0")
+
+          # Get commits since last tag
+          if [ "$LATEST_TAG" = "v0.0.0" ]; then
+            COMMITS=$(git log --pretty=format:"%s" --no-merges)
+          else
+            COMMITS=$(git log ${LATEST_TAG}..HEAD --pretty=format:"%s" --no-merges)
+          fi
+
+          echo "Analyzing commits:"
+          echo "$COMMITS"
+
+          # Initialize flags
+          HAS_FEATURE=false
+          HAS_FIX=false
+          HAS_BREAKING=false
+
+          # Analyze each commit
+          while IFS= read -r commit; do
+            if [[ "$commit" =~ ^FEATURE ]]; then
+              HAS_FEATURE=true
+              echo "Found FEATURE commit: $commit"
+            elif [[ "$commit" =~ ^FIX ]]; then
+              HAS_FIX=true
+              echo "Found FIX commit: $commit"
+            elif [[ "$commit" =~ ^REFACTOR ]]; then
+              HAS_FIX=true  # Treat refactor as patch
+              echo "Found REFACTOR commit: $commit"
+            fi
+            
+            # Check for breaking changes
+            if [[ "$commit" =~ BREAKING[[:space:]]CHANGE ]] || [[ "$commit" =~ "!" ]]; then
+              HAS_BREAKING=true
+              echo "Found BREAKING CHANGE: $commit"
+            fi
+          done <<< "$COMMITS"
+
+          # Determine version bump
+          if [ "$HAS_BREAKING" = true ]; then
+            BUMP_TYPE="major"
+          elif [ "$HAS_FEATURE" = true ]; then
+            BUMP_TYPE="minor"
+          elif [ "$HAS_FIX" = true ]; then
+            BUMP_TYPE="patch"
+          else
+            BUMP_TYPE="none"
+          fi
+
+          echo "bump_type=$BUMP_TYPE" >> $GITHUB_OUTPUT
+
+          if [ "$BUMP_TYPE" != "none" ]; then
+            NEW_VERSION=$(npx semver -i $BUMP_TYPE $CURRENT_VERSION)
+            echo "new_version=$NEW_VERSION" >> $GITHUB_OUTPUT
+            echo "should_release=true" >> $GITHUB_OUTPUT
+            echo "New version will be: $NEW_VERSION"
+          else
+            echo "should_release=false" >> $GITHUB_OUTPUT
+            echo "No version bump needed"
+          fi
+
+  build-only:
+    runs-on: ubuntu-latest
+    needs: [test-backend, lint-frontend]
+    if: ${{ github.ref == 'refs/heads/main' && contains(github.event.head_commit.message, '[skip-release]') }}
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v4
+
+      - name: Set up QEMU (enables multi-arch emulation)
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Log in to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Build and push SHA-only tags
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          push: true
+          platforms: linux/amd64,linux/arm64
+          build-args: |
+            APP_VERSION=dev-${{ github.sha }}
+          tags: |
+            rostislavdugin/postgresus:latest
+            rostislavdugin/postgresus:${{ github.sha }}
+
+  build-and-push:
+    runs-on: ubuntu-latest
+    needs: [determine-version]
+    if: ${{ needs.determine-version.outputs.should_release == 'true' }}
+    permissions:
+      contents: write
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v4
+
+      - name: Set up QEMU (enables multi-arch emulation)
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Log in to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Build and push with version tags
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          push: true
+          platforms: linux/amd64,linux/arm64
+          build-args: |
+            APP_VERSION=${{ needs.determine-version.outputs.new_version }}
+          tags: |
+            rostislavdugin/postgresus:latest
+            rostislavdugin/postgresus:v${{ needs.determine-version.outputs.new_version }}
+            rostislavdugin/postgresus:${{ github.sha }}
+
+  release:
+    runs-on: ubuntu-latest
+    needs: [determine-version, build-and-push]
+    if: ${{ needs.determine-version.outputs.should_release == 'true' }}
+    permissions:
+      contents: write
+      pull-requests: write
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Generate changelog
+        id: changelog
+        run: |
+          NEW_VERSION="${{ needs.determine-version.outputs.new_version }}"
+          LATEST_TAG=$(git describe --tags --abbrev=0 2>/dev/null || echo "v0.0.0")
+
+          # Get commits since last tag
+          if [ "$LATEST_TAG" = "v0.0.0" ]; then
+            COMMITS=$(git log --pretty=format:"%s|%H|%an|%ad" --date=short --no-merges)
+          else
+            COMMITS=$(git log ${LATEST_TAG}..HEAD --pretty=format:"%s|%H|%an|%ad" --date=short --no-merges)
+          fi
+
+          # Create changelog
+          CHANGELOG="# Changelog\n\n## [${NEW_VERSION}] - $(date +%Y-%m-%d)\n\n"
+
+          # Group commits by type and area
+          FEATURES=""
+          FIXES=""
+          REFACTORS=""
+
+          while IFS= read -r line; do
+            if [ -n "$line" ]; then
+              COMMIT_MSG=$(echo "$line" | cut -d'|' -f1)
+              COMMIT_HASH=$(echo "$line" | cut -d'|' -f2)
+              SHORT_HASH=${COMMIT_HASH:0:7}
+              
+              # Parse commit message format: TYPE (area): description
+              if [[ "$COMMIT_MSG" == FEATURE* ]]; then
+                TEMP="${COMMIT_MSG#FEATURE}"
+                TEMP="${TEMP#"${TEMP%%[![:space:]]*}"}"
+                if [[ "$TEMP" == \(* ]]; then
+                  AREA=$(echo "$TEMP" | sed 's/^(\([^)]*\)).*/\1/')
+                  DESC=$(echo "$TEMP" | sed 's/^([^)]*):[[:space:]]*//')
+                  FEATURES="${FEATURES}- **${AREA}**: ${DESC} ([${SHORT_HASH}](https://github.com/${{ github.repository }}/commit/${COMMIT_HASH}))\n"
+                fi
+              elif [[ "$COMMIT_MSG" == FIX* ]]; then
+                TEMP="${COMMIT_MSG#FIX}"
+                TEMP="${TEMP#"${TEMP%%[![:space:]]*}"}"
+                if [[ "$TEMP" == \(* ]]; then
+                  AREA=$(echo "$TEMP" | sed 's/^(\([^)]*\)).*/\1/')
+                  DESC=$(echo "$TEMP" | sed 's/^([^)]*):[[:space:]]*//')
+                  FIXES="${FIXES}- **${AREA}**: ${DESC} ([${SHORT_HASH}](https://github.com/${{ github.repository }}/commit/${COMMIT_HASH}))\n"
+                fi
+              elif [[ "$COMMIT_MSG" == REFACTOR* ]]; then
+                TEMP="${COMMIT_MSG#REFACTOR}"
+                TEMP="${TEMP#"${TEMP%%[![:space:]]*}"}"
+                if [[ "$TEMP" == \(* ]]; then
+                  AREA=$(echo "$TEMP" | sed 's/^(\([^)]*\)).*/\1/')
+                  DESC=$(echo "$TEMP" | sed 's/^([^)]*):[[:space:]]*//')
+                  REFACTORS="${REFACTORS}- **${AREA}**: ${DESC} ([${SHORT_HASH}](https://github.com/${{ github.repository }}/commit/${COMMIT_HASH}))\n"
+                fi
+              fi
+            fi
+          done <<< "$COMMITS"
+
+          # Build changelog sections
+          if [ -n "$FEATURES" ]; then
+            CHANGELOG="${CHANGELOG}### ✨ Features\n${FEATURES}\n"
+          fi
+
+          if [ -n "$FIXES" ]; then
+            CHANGELOG="${CHANGELOG}### 🐛 Bug Fixes\n${FIXES}\n"
+          fi
+
+          if [ -n "$REFACTORS" ]; then
+            CHANGELOG="${CHANGELOG}### 🔨 Refactoring\n${REFACTORS}\n"
+          fi
+
+          # Add Docker image info
+          CHANGELOG="${CHANGELOG}### 🐳 Docker\n"
+          CHANGELOG="${CHANGELOG}- **Image**: \`rostislavdugin/postgresus:v${NEW_VERSION}\`\n"
+          CHANGELOG="${CHANGELOG}- **Platforms**: linux/amd64, linux/arm64\n\n"
+
+          # Set output for GitHub release
+          {
+            echo 'changelog<<EOF'
+            echo -e "$CHANGELOG"
+            echo EOF
+          } >> $GITHUB_OUTPUT
+
+      - name: Create GitHub Release
+        uses: actions/create-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          tag_name: v${{ needs.determine-version.outputs.new_version }}
+          release_name: Release v${{ needs.determine-version.outputs.new_version }}
+          body: ${{ steps.changelog.outputs.changelog }}
+          draft: false
+          prerelease: false

.github/workflows/docker.yml

@@ -1,121 +0,0 @@
-name: Build & push Docker image
-
-on:
-  push:
-    branches: [main]
-  workflow_dispatch: {}
-
-jobs:
-  lint-backend:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check out code
-        uses: actions/checkout@v4
-
-      - name: Set up Go
-        uses: actions/setup-go@v5
-        with:
-          go-version: "1.23.3"
-
-      - name: Cache Go modules
-        uses: actions/cache@v4
-        with:
-          path: |
-            ~/go/pkg/mod
-            ~/.cache/go-build
-          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
-          restore-keys: |
-            ${{ runner.os }}-go-
-
-      - name: Install golangci-lint
-        run: |
-          curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b $(go env GOPATH)/bin v1.60.3
-          echo "$(go env GOPATH)/bin" >> $GITHUB_PATH
-
-      - name: Install swag for swagger generation
-        run: go install github.com/swaggo/swag/cmd/swag@v1.16.4
-
-      - name: Generate swagger docs
-        run: |
-          cd backend
-          swag init -d . -g cmd/main.go -o swagger
-
-      - name: Run golangci-lint
-        run: |
-          cd backend
-          golangci-lint run
-
-      - name: Verify go mod tidy
-        run: |
-          cd backend
-          go mod tidy
-          git diff --exit-code go.mod go.sum || (echo "go mod tidy made changes, please run 'go mod tidy' and commit the changes" && exit 1)
-
-  lint-frontend:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check out code
-        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 dependencies
-        run: |
-          cd frontend
-          npm ci
-
-      - name: Check if prettier was run
-        run: |
-          cd frontend
-          npm run format
-          git diff --exit-code || (echo "Prettier made changes, please run 'npm run format' and commit the changes" && exit 1)
-
-      - name: Check if linter was run
-        run: |
-          cd frontend
-          npm run lint
-
-  build-and-push:
-    runs-on: ubuntu-latest
-    needs: [lint-backend, lint-frontend]
-
-    steps:
-      - name: Check out code
-        uses: actions/checkout@v4
-
-      - name: Set up QEMU (enables multi-arch emulation)
-        uses: docker/setup-qemu-action@v3
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-
-      - name: Log in to Docker Hub
-        uses: docker/login-action@v3
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-
-      - name: Build and push
-        uses: docker/build-push-action@v5
-        with:
-          context: .
-          push: true
-          platforms: linux/amd64,linux/arm64 # both chip families
-          tags: |
-            rostislavdugin/postgresus:latest
-            rostislavdugin/postgresus:${{ github.sha }}
-
-      - name: Update Docker Hub description
-        uses: peter-evans/dockerhub-description@v4
-        continue-on-error: true
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_PASSWORD }}
-          repository: rostislavdugin/postgresus
-          short-description: "Free PostgreSQL monitoring & backup solution"
-          readme-filepath: ./README.md

.github/workflows/release.yml

@@ -1,235 +0,0 @@
-name: Automated Release
-
-on:
-  push:
-    branches: [main]
-  workflow_dispatch:
-
-jobs:
-  release:
-    runs-on: ubuntu-latest
-    if: ${{ !contains(github.event.head_commit.message, '[skip-release]') }}
-    permissions:
-      contents: write
-      pull-requests: write
-
-    steps:
-      - name: Check out code
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          token: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Set up Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: "20"
-
-      - name: Install dependencies
-        run: |
-          npm install -g conventional-changelog-cli
-          npm install -g semver
-
-      - name: Get current version
-        id: current_version
-        run: |
-          # Get the latest tag, default to 0.0.0 if no tags exist
-          LATEST_TAG=$(git describe --tags --abbrev=0 2>/dev/null || echo "v0.0.0")
-          echo "current_version=${LATEST_TAG#v}" >> $GITHUB_OUTPUT
-          echo "Current version: ${LATEST_TAG#v}"
-
-      - name: Analyze commits and determine version bump
-        id: version_bump
-        run: |
-          CURRENT_VERSION="${{ steps.current_version.outputs.current_version }}"
-          LATEST_TAG=$(git describe --tags --abbrev=0 2>/dev/null || echo "v0.0.0")
-
-          # Get commits since last tag
-          if [ "$LATEST_TAG" = "v0.0.0" ]; then
-            COMMITS=$(git log --pretty=format:"%s" --no-merges)
-          else
-            COMMITS=$(git log ${LATEST_TAG}..HEAD --pretty=format:"%s" --no-merges)
-          fi
-
-          echo "Analyzing commits:"
-          echo "$COMMITS"
-
-          # Initialize flags
-          HAS_FEATURE=false
-          HAS_FIX=false
-          HAS_BREAKING=false
-
-          # Analyze each commit
-          while IFS= read -r commit; do
-            if [[ "$commit" =~ ^FEATURE ]]; then
-              HAS_FEATURE=true
-              echo "Found FEATURE commit: $commit"
-            elif [[ "$commit" =~ ^FIX ]]; then
-              HAS_FIX=true
-              echo "Found FIX commit: $commit"
-            elif [[ "$commit" =~ ^REFACTOR ]]; then
-              HAS_FIX=true  # Treat refactor as patch
-              echo "Found REFACTOR commit: $commit"
-            fi
-            
-            # Check for breaking changes
-            if [[ "$commit" =~ BREAKING[[:space:]]CHANGE ]] || [[ "$commit" =~ "!" ]]; then
-              HAS_BREAKING=true
-              echo "Found BREAKING CHANGE: $commit"
-            fi
-          done <<< "$COMMITS"
-
-          # Determine version bump
-          if [ "$HAS_BREAKING" = true ]; then
-            BUMP_TYPE="major"
-          elif [ "$HAS_FEATURE" = true ]; then
-            BUMP_TYPE="minor"
-          elif [ "$HAS_FIX" = true ]; then
-            BUMP_TYPE="patch"
-          else
-            BUMP_TYPE="none"
-          fi
-
-          echo "bump_type=$BUMP_TYPE" >> $GITHUB_OUTPUT
-
-          if [ "$BUMP_TYPE" != "none" ]; then
-            NEW_VERSION=$(npx semver -i $BUMP_TYPE $CURRENT_VERSION)
-            echo "new_version=$NEW_VERSION" >> $GITHUB_OUTPUT
-            echo "should_release=true" >> $GITHUB_OUTPUT
-            echo "New version will be: $NEW_VERSION"
-          else
-            echo "should_release=false" >> $GITHUB_OUTPUT
-            echo "No version bump needed"
-          fi
-
-      - name: Generate changelog
-        id: changelog
-        if: steps.version_bump.outputs.should_release == 'true'
-        run: |
-          CURRENT_VERSION="${{ steps.current_version.outputs.current_version }}"
-          NEW_VERSION="${{ steps.version_bump.outputs.new_version }}"
-          LATEST_TAG=$(git describe --tags --abbrev=0 2>/dev/null || echo "v0.0.0")
-
-          # Get commits since last tag
-          if [ "$LATEST_TAG" = "v0.0.0" ]; then
-            COMMITS=$(git log --pretty=format:"%s|%H|%an|%ad" --date=short --no-merges)
-          else
-            COMMITS=$(git log ${LATEST_TAG}..HEAD --pretty=format:"%s|%H|%an|%ad" --date=short --no-merges)
-          fi
-
-          # Create changelog
-          CHANGELOG="# Changelog\n\n## [${NEW_VERSION}] - $(date +%Y-%m-%d)\n\n"
-
-          # Group commits by type and area
-          FEATURES=""
-          FIXES=""
-          REFACTORS=""
-
-          while IFS= read -r line; do
-            if [ -n "$line" ]; then
-              COMMIT_MSG=$(echo "$line" | cut -d'|' -f1)
-              COMMIT_HASH=$(echo "$line" | cut -d'|' -f2)
-              COMMIT_AUTHOR=$(echo "$line" | cut -d'|' -f3)
-              COMMIT_DATE=$(echo "$line" | cut -d'|' -f4)
-              SHORT_HASH=${COMMIT_HASH:0:7}
-              
-              # Parse commit message format: TYPE (area): description
-              if [[ "$COMMIT_MSG" == FEATURE* ]]; then
-                # Extract area and description
-                TEMP="${COMMIT_MSG#FEATURE}"
-                TEMP="${TEMP#"${TEMP%%[![:space:]]*}"}" # trim leading spaces
-                if [[ "$TEMP" == \(* ]]; then
-                  AREA=$(echo "$TEMP" | sed 's/^(\([^)]*\)).*/\1/')
-                  DESC=$(echo "$TEMP" | sed 's/^([^)]*):[[:space:]]*//')
-                  FEATURES="${FEATURES}- **${AREA}**: ${DESC} ([${SHORT_HASH}](https://github.com/${{ github.repository }}/commit/${COMMIT_HASH}))\n"
-                fi
-              elif [[ "$COMMIT_MSG" == FIX* ]]; then
-                # Extract area and description
-                TEMP="${COMMIT_MSG#FIX}"
-                TEMP="${TEMP#"${TEMP%%[![:space:]]*}"}" # trim leading spaces
-                if [[ "$TEMP" == \(* ]]; then
-                  AREA=$(echo "$TEMP" | sed 's/^(\([^)]*\)).*/\1/')
-                  DESC=$(echo "$TEMP" | sed 's/^([^)]*):[[:space:]]*//')
-                  FIXES="${FIXES}- **${AREA}**: ${DESC} ([${SHORT_HASH}](https://github.com/${{ github.repository }}/commit/${COMMIT_HASH}))\n"
-                fi
-              elif [[ "$COMMIT_MSG" == REFACTOR* ]]; then
-                # Extract area and description
-                TEMP="${COMMIT_MSG#REFACTOR}"
-                TEMP="${TEMP#"${TEMP%%[![:space:]]*}"}" # trim leading spaces
-                if [[ "$TEMP" == \(* ]]; then
-                  AREA=$(echo "$TEMP" | sed 's/^(\([^)]*\)).*/\1/')
-                  DESC=$(echo "$TEMP" | sed 's/^([^)]*):[[:space:]]*//')
-                  REFACTORS="${REFACTORS}- **${AREA}**: ${DESC} ([${SHORT_HASH}](https://github.com/${{ github.repository }}/commit/${COMMIT_HASH}))\n"
-                fi
-              fi
-            fi
-          done <<< "$COMMITS"
-
-          # Build changelog sections
-          if [ -n "$FEATURES" ]; then
-            CHANGELOG="${CHANGELOG}### ✨ Features\n${FEATURES}\n"
-          fi
-
-          if [ -n "$FIXES" ]; then
-            CHANGELOG="${CHANGELOG}### 🐛 Bug Fixes\n${FIXES}\n"
-          fi
-
-          if [ -n "$REFACTORS" ]; then
-            CHANGELOG="${CHANGELOG}### 🔨 Refactoring\n${REFACTORS}\n"
-          fi
-
-                    # Save changelog to file
-          echo -e "$CHANGELOG" > RELEASE_CHANGELOG.md
-
-          # Update main CHANGELOG.md - preserve all version history
-          if [ -f "CHANGELOG.md" ]; then
-            # Get the header until [Unreleased] section
-            sed -n '1,/## \[Unreleased\]/p' CHANGELOG.md > NEW_CHANGELOG.md
-            echo "" >> NEW_CHANGELOG.md
-            # Add the new release (without the "# Changelog" header)
-            echo "## [${NEW_VERSION}] - $(date +%Y-%m-%d)" >> NEW_CHANGELOG.md
-            echo "" >> NEW_CHANGELOG.md
-            
-            # Add the new release sections
-            if [ -n "$FEATURES" ]; then
-              echo "### ✨ Features" >> NEW_CHANGELOG.md
-              echo -e "$FEATURES" >> NEW_CHANGELOG.md
-            fi
-            
-            if [ -n "$FIXES" ]; then
-              echo "### 🐛 Bug Fixes" >> NEW_CHANGELOG.md
-              echo -e "$FIXES" >> NEW_CHANGELOG.md
-            fi
-            
-            if [ -n "$REFACTORS" ]; then
-              echo "### 🔨 Refactoring" >> NEW_CHANGELOG.md
-              echo -e "$REFACTORS" >> NEW_CHANGELOG.md
-            fi
-            
-            # Get existing releases (everything after first ## [version] pattern)
-            sed -n '/## \[[0-9]/,$p' CHANGELOG.md >> NEW_CHANGELOG.md
-            
-            # Replace the original file
-            mv NEW_CHANGELOG.md CHANGELOG.md
-          else
-            echo -e "$CHANGELOG" > CHANGELOG.md
-          fi
-
-          # Set output for GitHub release (escape newlines)
-          {
-            echo 'changelog<<EOF'
-            echo -e "$CHANGELOG"
-            echo EOF
-          } >> $GITHUB_OUTPUT
-
-      - name: Create GitHub Release
-        if: steps.version_bump.outputs.should_release == 'true'
-        uses: actions/create-release@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          tag_name: v${{ steps.version_bump.outputs.new_version }}
-          release_name: Release v${{ steps.version_bump.outputs.new_version }}
-          body: ${{ steps.changelog.outputs.changelog }}
-          draft: false
-          prerelease: false

.gitignore

@@ -3,4 +3,5 @@ postgresus-data/
 .env
 pgdata/
 docker-compose.yml
-node_modules/
+node_modules/
+.idea

.pre-commit-config.yaml

@@ -0,0 +1,29 @@
+# Pre-commit configuration
+# See https://pre-commit.com for more information
+repos:
+  # Frontend checks
+  - repo: local
+    hooks:
+      - id: frontend-format
+        name: Frontend Format (Prettier)
+        entry: powershell -Command "cd frontend; npm run format"
+        language: system
+        files: ^frontend/.*\.(ts|tsx|js|jsx|json|css|md)$
+        pass_filenames: false
+
+      - id: frontend-lint
+        name: Frontend Lint (ESLint)
+        entry: powershell -Command "cd frontend; npm run lint"
+        language: system
+        files: ^frontend/.*\.(ts|tsx|js|jsx)$
+        pass_filenames: false
+
+  # Backend checks
+  - repo: local
+    hooks:
+      - id: backend-format-and-lint
+        name: Backend Format & Lint (golangci-lint)
+        entry: powershell -Command "cd backend; golangci-lint fmt; golangci-lint run"
+        language: system
+        files: ^backend/.*\.go$
+        pass_filenames: false

CHANGELOG.md

@@ -1,10 +0,0 @@
-# Changelog
-
-All notable changes to this project will be documented in this file.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
-and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-
-## [Unreleased]
-
-<!-- This file is automatically updated by the release workflow -->

Dockerfile

@@ -3,24 +3,40 @@ FROM --platform=$BUILDPLATFORM node:24-alpine AS frontend-build
 
 WORKDIR /frontend
 
+# Add version for the frontend build
+ARG APP_VERSION=dev
+ENV VITE_APP_VERSION=$APP_VERSION
+
 COPY frontend/package.json frontend/package-lock.json ./
 RUN npm ci
 COPY frontend/ ./
 
 # Copy .env file (with fallback to .env.production.example)
 RUN if [ ! -f .env ]; then \
-      if [ -f .env.production.example ]; then \
-        cp .env.production.example .env; \
-      fi; \
-    fi
+  if [ -f .env.production.example ]; then \
+  cp .env.production.example .env; \
+  fi; \
+  fi
 
 RUN npm run build
 
 # ========= BUILD BACKEND =========
+# Backend build stage
 FROM --platform=$BUILDPLATFORM golang:1.23.3 AS backend-build
 
-# Install Go public tools needed in runtime
-RUN curl -fsSL https://raw.githubusercontent.com/pressly/goose/master/install.sh | sh
+# Make TARGET args available early so tools built here match the final image arch
+ARG TARGETOS
+ARG TARGETARCH
+
+# Install Go public tools needed in runtime. Use `go build` for goose so the
+# binary is compiled for the target architecture instead of downloading a
+# prebuilt binary which may have the wrong architecture (causes exec format
+# errors on ARM).
+RUN git clone --depth 1 --branch v3.24.3 https://github.com/pressly/goose.git /tmp/goose && \
+  cd /tmp/goose/cmd/goose && \
+  GOOS=${TARGETOS:-linux} GOARCH=${TARGETARCH:-amd64} \
+  go build -o /usr/local/bin/goose . && \
+  rm -rf /tmp/goose
 RUN go install github.com/swaggo/swag/cmd/swag@v1.16.4
 
 # Set working directory
@@ -45,25 +61,38 @@ ARG TARGETOS
 ARG TARGETARCH
 ARG TARGETVARIANT
 RUN CGO_ENABLED=0 \
-    GOOS=$TARGETOS \
-    GOARCH=$TARGETARCH \
-    go build -o /app/main ./cmd/main.go
+  GOOS=$TARGETOS \
+  GOARCH=$TARGETARCH \
+  go build -o /app/main ./cmd/main.go
 
 
 # ========= RUNTIME =========
-FROM --platform=$TARGETPLATFORM debian:bookworm-slim
+FROM debian:bookworm-slim
 
-# Install PostgreSQL client tools (versions 13-17)
+# Add version metadata to runtime image
+ARG APP_VERSION=dev
+LABEL org.opencontainers.image.version=$APP_VERSION
+ENV APP_VERSION=$APP_VERSION
+
+# Set production mode for Docker containers
+ENV ENV_MODE=production
+
+# Install PostgreSQL server and client tools (versions 13-17)
 RUN apt-get update && apt-get install -y --no-install-recommends \
-       wget ca-certificates gnupg lsb-release && \
-    wget -qO- https://www.postgresql.org/media/keys/ACCC4CF8.asc | apt-key add - && \
-    echo "deb http://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" \
-      > /etc/apt/sources.list.d/pgdg.list && \
-    apt-get update && \
-    apt-get install -y --no-install-recommends \
-       postgresql-client-13 postgresql-client-14 postgresql-client-15 \
-       postgresql-client-16 postgresql-client-17 && \
-    rm -rf /var/lib/apt/lists/*
+  wget ca-certificates gnupg lsb-release sudo gosu && \
+  wget -qO- https://www.postgresql.org/media/keys/ACCC4CF8.asc | apt-key add - && \
+  echo "deb http://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" \
+  > /etc/apt/sources.list.d/pgdg.list && \
+  apt-get update && \
+  apt-get install -y --no-install-recommends \
+  postgresql-17 postgresql-18 postgresql-client-13 postgresql-client-14 postgresql-client-15 \
+  postgresql-client-16 postgresql-client-17 postgresql-client-18 && \
+  rm -rf /var/lib/apt/lists/*
+
+# Create postgres user and set up directories
+RUN useradd -m -s /bin/bash postgres || true && \
+  mkdir -p /postgresus-data/pgdata && \
+  chown -R postgres:postgres /postgresus-data/pgdata
 
 WORKDIR /app
 
@@ -82,12 +111,78 @@ COPY --from=backend-build /app/ui/build ./ui/build
 # Copy .env file (with fallback to .env.production.example)
 COPY backend/.env* /app/
 RUN if [ ! -f /app/.env ]; then \
-      if [ -f /app/.env.production.example ]; then \
-        cp /app/.env.production.example /app/.env; \
-      fi; \
+  if [ -f /app/.env.production.example ]; then \
+  cp /app/.env.production.example /app/.env; \
+  fi; \
+  fi
+
+# Create startup script
+COPY <<EOF /app/start.sh
+#!/bin/bash
+set -e
+
+# PostgreSQL 17 binary paths
+PG_BIN="/usr/lib/postgresql/17/bin"
+
+# Ensure proper ownership of data directory
+echo "Setting up data directory permissions..."
+mkdir -p /postgresus-data/pgdata
+chown -R postgres:postgres /postgresus-data
+
+# Initialize PostgreSQL if not already initialized
+if [ ! -s "/postgresus-data/pgdata/PG_VERSION" ]; then
+    echo "Initializing PostgreSQL database..."
+    gosu postgres \$PG_BIN/initdb -D /postgresus-data/pgdata --encoding=UTF8 --locale=C.UTF-8
+    
+    # Configure PostgreSQL
+    echo "host all all 127.0.0.1/32 md5" >> /postgresus-data/pgdata/pg_hba.conf
+    echo "local all all trust" >> /postgresus-data/pgdata/pg_hba.conf
+    echo "port = 5437" >> /postgresus-data/pgdata/postgresql.conf
+    echo "listen_addresses = 'localhost'" >> /postgresus-data/pgdata/postgresql.conf
+    echo "shared_buffers = 256MB" >> /postgresus-data/pgdata/postgresql.conf
+    echo "max_connections = 100" >> /postgresus-data/pgdata/postgresql.conf
+fi
+
+# Start PostgreSQL in background
+echo "Starting PostgreSQL..."
+gosu postgres \$PG_BIN/postgres -D /postgresus-data/pgdata -p 5437 &
+POSTGRES_PID=\$!
+
+# Wait for PostgreSQL to be ready
+echo "Waiting for PostgreSQL to be ready..."
+for i in {1..30}; do
+    if gosu postgres \$PG_BIN/pg_isready -p 5437 -h localhost >/dev/null 2>&1; then
+        echo "PostgreSQL is ready!"
+        break
     fi
+    if [ \$i -eq 30 ]; then
+        echo "PostgreSQL failed to start"
+        exit 1
+    fi
+    sleep 1
+done
+
+# Create database and set password for postgres user
+echo "Setting up database and user..."
+gosu postgres \$PG_BIN/psql -p 5437 -h localhost -d postgres << 'SQL'
+ALTER USER postgres WITH PASSWORD 'Q1234567';
+SELECT 'CREATE DATABASE postgresus OWNER postgres'
+WHERE NOT EXISTS (SELECT FROM pg_database WHERE datname = 'postgresus')
+\\gexec
+\\q
+SQL
+
+# Start the main application
+echo "Starting Postgresus application..."
+exec ./main
+EOF
+
+RUN chmod +x /app/start.sh
 
 EXPOSE 4005
 
-ENTRYPOINT ["./main"]
-CMD []
+# Volume for PostgreSQL data
+VOLUME ["/postgresus-data"]
+
+ENTRYPOINT ["/app/start.sh"]
+CMD []

LICENSE

@@ -1,21 +1,202 @@
-MIT License
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
 
-Copyright (c) 2025 Postgresus
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+   1. Definitions.
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+      "Licensor" shall mean the copyright owner or entity granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (which shall not include communications that are solely written
+      by You).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based upon (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and derivative works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control
+      systems, and issue tracking systems that are managed by, or on behalf
+      of, the Licensor for the purpose of discussing and improving the Work,
+      but excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to use, reproduce, modify, distribute, prepare
+      Derivative Works of, and publicly display, publicly perform,
+      sublicense, and distribute the Work and such Derivative Works in
+      Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright notice to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. When redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "license" line as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2025 LogBull
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -1,8 +1,17 @@
 <div align="center">
-  <img src="assets/logo.svg" alt="Postgresus Logo" width="250"/>
+  <img src="assets/logo.svg" style="margin-bottom: 20px;" alt="Postgresus Logo" width="250"/>
+
+  <h3>PostgreSQL backup</h3>
+  <p>Free, open source and self-hosted solution for automated PostgreSQL backups. With multiple storage options and notifications</p>
   
-  <h3>PostgreSQL monitoring and backup</h3>
-  <p>Free, open source and self-hosted solution for automated PostgreSQL monitoring and backups. With multiple storage options and notifications</p>
+  <!-- Badges -->
+  [![Apache 2.0 License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](LICENSE)
+  [![Docker Pulls](https://img.shields.io/docker/pulls/rostislavdugin/postgresus?color=brightgreen)](https://hub.docker.com/r/rostislavdugin/postgresus)
+  [![Platform](https://img.shields.io/badge/platform-linux%20%7C%20macos%20%7C%20windows-lightgrey)](https://github.com/RostislavDugin/postgresus)
+  
+  [![PostgreSQL](https://img.shields.io/badge/PostgreSQL-13%20%7C%2014%20%7C%2015%20%7C%2016%20%7C%2017%20%7C%2018-336791?logo=postgresql&logoColor=white)](https://www.postgresql.org/)
+  [![Self Hosted](https://img.shields.io/badge/self--hosted-yes-brightgreen)](https://github.com/RostislavDugin/postgresus)
+  [![Open Source](https://img.shields.io/badge/open%20source-❤️-red)](https://github.com/RostislavDugin/postgresus)
   
   <p>
     <a href="#-features">Features</a> •
@@ -11,8 +20,14 @@
     <a href="#-license">License</a> •
     <a href="#-contributing">Contributing</a>
   </p>
+
+  <p style="margin-top: 20px; margin-bottom: 20px; font-size: 1.2em;">
+    <a href="https://postgresus.com" target="_blank"><strong>🌐 Postgresus website</strong></a>
+  </p>
   
   <img src="assets/dashboard.svg" alt="Postgresus Dashboard" width="800"/>
+  
+ 
 </div>
 
 ---
@@ -28,18 +43,18 @@
 ### 🗄️ **Multiple Storage Destinations**
 
 - **Local storage**: Keep backups on your VPS/server
-- **Cloud storage**: S3, Cloudflare R2, Google Drive, Dropbox, and more (coming soon)
+- **Cloud storage**: S3, Cloudflare R2, Google Drive, NAS, Dropbox and more
 - **Secure**: All data stays under your control
 
 ### 📱 **Smart Notifications**
 
-- **Multiple channels**: Email, Telegram, Slack, webhooks (coming soon)
+- **Multiple channels**: Email, Telegram, Slack, Discord, webhooks
 - **Real-time updates**: Success and failure notifications
 - **Team integration**: Perfect for DevOps workflows
 
 ### 🐘 **PostgreSQL Support**
 
-- **Multiple versions**: PostgreSQL 13, 14, 15, 16 and 17
+- **Multiple versions**: PostgreSQL 13, 14, 15, 16, 17 and 18
 - **SSL support**: Secure connections available
 - **Easy restoration**: One-click restore from any backup
 
@@ -47,13 +62,15 @@
 
 - **Docker-based**: Easy deployment and management
 - **Privacy-first**: All your data stays on your infrastructure
-- **Open source**: MIT licensed, inspect every line of code
+- **Open source**: Apache 2.0 licensed, inspect every line of code
 
-### 📊 **Monitoring & Insights**
+### 📦 Installation
 
-- **Real-time metrics**: Track database health
-- **Historical data**: View trends and patterns over time
-- **Alert system**: Get notified when issues are detected
+You have three ways to install Postgresus:
+
+- Script (recommended)
+- Simple Docker run
+- Docker Compose setup
 
 <img src="assets/healthchecks.svg" alt="Postgresus Dashboard" width="800"/>
 
@@ -61,15 +78,15 @@
 
 ## 📦 Installation
 
-You have two ways to install Postgresus: via automated script (recommended) or manual Docker Compose setup.
+You have three ways to install Postgresus: automated script (recommended), simple Docker run, or Docker Compose setup.
 
 ### Option 1: Automated Installation Script (Recommended, Linux only)
 
 The installation script will:
 
-- ✅ Install Docker with Docker Compose (if not already installed)
-- ✅ Create optimized `docker-compose.yml` configuration
-- ✅ Set up automatic startup on system reboot via cron
+- ✅ Install Docker with Docker Compose(if not already installed)
+- ✅ Set up Postgresus
+- ✅ Configure automatic startup on system reboot
 
 ```bash
 sudo apt-get install -y curl && \
@@ -77,7 +94,26 @@ sudo curl -sSL https://raw.githubusercontent.com/RostislavDugin/postgresus/refs/
 | sudo bash
 ```
 
-### Option 2: Manual Docker Compose Setup
+### Option 2: Simple Docker Run
+
+The easiest way to run Postgresus with embedded PostgreSQL:
+
+```bash
+docker run -d \
+  --name postgresus \
+  -p 4005:4005 \
+  -v ./postgresus-data:/postgresus-data \
+  --restart unless-stopped \
+  rostislavdugin/postgresus:latest
+```
+
+This single command will:
+
+- ✅ Start Postgresus
+- ✅ Store all data in `./postgresus-data` directory
+- ✅ Automatically restart on system reboot
+
+### Option 3: Docker Compose Setup
 
 Create a `docker-compose.yml` file with the following configuration:
 
@@ -92,29 +128,6 @@ services:
       - "4005:4005"
     volumes:
       - ./postgresus-data:/postgresus-data
-    depends_on:
-      postgresus-db:
-        condition: service_healthy
-    restart: unless-stopped
-
-  postgresus-db:
-    container_name: postgresus-db
-    image: postgres:17
-    # we use default values, but do not expose
-    # PostgreSQL ports so it is safe
-    environment:
-      - POSTGRES_DB=postgresus
-      - POSTGRES_USER=postgres
-      - POSTGRES_PASSWORD=Q1234567
-    volumes:
-      - ./pgdata:/var/lib/postgresql/data
-    command: -p 5437
-    shm_size: 10gb
-    healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U postgres -d postgresus -p 5437"]
-      interval: 5s
-      timeout: 5s
-      retries: 5
     restart: unless-stopped
 ```
 
@@ -148,7 +161,7 @@ docker exec -it postgresus ./main --new-password="YourNewSecurePassword123"
 
 ## 📝 License
 
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+This project is licensed under the Apache 2.0 License - see the [LICENSE](LICENSE) file for details.
 
 ---
 

backend/.cursor/rules/codestyle-rule.mdc

@@ -1,14 +1,152 @@
 ---
-description: 
-globs: 
+description:
+globs:
 alwaysApply: true
 ---
+
 Always place private methods to the bottom of file
 
-Code should look like:
+**This rule applies to ALL Go files including tests, services, controllers, repositories, etc.**
 
-type SomeService struct {
-    func PublicMethod(...) ...
+In Go, exported (public) functions/methods start with uppercase letters, while unexported (private) ones start with lowercase letters.
 
-    func privateMethod(...) ...
-}
+## Structure Order:
+
+1. Type definitions and constants
+2. Public methods/functions (uppercase)
+3. Private methods/functions (lowercase)
+
+## Examples:
+
+### Service with methods:
+
+```go
+type UserService struct {
+    repository *UserRepository
+}
+
+// Public methods first
+func (s *UserService) CreateUser(user *User) error {
+    if err := s.validateUser(user); err != nil {
+        return err
+    }
+    return s.repository.Save(user)
+}
+
+func (s *UserService) GetUser(id uuid.UUID) (*User, error) {
+    return s.repository.FindByID(id)
+}
+
+// Private methods at the bottom
+func (s *UserService) validateUser(user *User) error {
+    if user.Name == "" {
+        return errors.New("name is required")
+    }
+    return nil
+}
+```
+
+### Package-level functions:
+
+```go
+package utils
+
+// Public functions first
+func ProcessData(data []byte) (Result, error) {
+    cleaned := sanitizeInput(data)
+    return parseData(cleaned)
+}
+
+func ValidateInput(input string) bool {
+    return isValidFormat(input) && checkLength(input)
+}
+
+// Private functions at the bottom
+func sanitizeInput(data []byte) []byte {
+    // implementation
+}
+
+func parseData(data []byte) (Result, error) {
+    // implementation
+}
+
+func isValidFormat(input string) bool {
+    // implementation
+}
+
+func checkLength(input string) bool {
+    // implementation
+}
+```
+
+### Test files:
+
+```go
+package user_test
+
+// Public test functions first
+func Test_CreateUser_ValidInput_UserCreated(t *testing.T) {
+    user := createTestUser()
+    result, err := service.CreateUser(user)
+
+    assert.NoError(t, err)
+    assert.NotNil(t, result)
+}
+
+func Test_GetUser_ExistingUser_ReturnsUser(t *testing.T) {
+    user := createTestUser()
+    // test implementation
+}
+
+// Private helper functions at the bottom
+func createTestUser() *User {
+    return &User{
+        Name:  "Test User",
+        Email: "test@example.com",
+    }
+}
+
+func setupTestDatabase() *Database {
+    // setup implementation
+}
+```
+
+### Controller example:
+
+```go
+type ProjectController struct {
+    service *ProjectService
+}
+
+// Public HTTP handlers first
+func (c *ProjectController) CreateProject(ctx *gin.Context) {
+    var request CreateProjectRequest
+    if err := ctx.ShouldBindJSON(&request); err != nil {
+        c.handleError(ctx, err)
+        return
+    }
+    // handler logic
+}
+
+func (c *ProjectController) GetProject(ctx *gin.Context) {
+    projectID := c.extractProjectID(ctx)
+    // handler logic
+}
+
+// Private helper methods at the bottom
+func (c *ProjectController) handleError(ctx *gin.Context, err error) {
+    ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+}
+
+func (c *ProjectController) extractProjectID(ctx *gin.Context) uuid.UUID {
+    return uuid.MustParse(ctx.Param("projectId"))
+}
+```
+
+## Key Points:
+
+- **Exported/Public** = starts with uppercase letter (CreateUser, GetProject)
+- **Unexported/Private** = starts with lowercase letter (validateUser, handleError)
+- This improves code readability by showing the public API first
+- Private helpers are implementation details, so they go at the bottom
+- Apply this rule consistently across ALL Go files in the project

backend/.cursor/rules/comments.mdc

@@ -1,7 +1,45 @@
 ---
-description: 
-globs: 
+description:
+globs:
 alwaysApply: true
 ---
-Do not write obvious comments.
-Write meaningful code, give meaningful names
+
+## Comment Guidelines
+
+1. **No obvious comments** - Don't state what the code already clearly shows
+2. **Functions and variables should have meaningful names** - Code should be self-documenting
+3. **Comments for unclear code only** - Only add comments when code logic isn't immediately clear
+
+## Key Principles:
+
+- **Code should tell a story** - Use descriptive variable and function names
+- **Comments explain WHY, not WHAT** - The code shows what happens, comments explain business logic or complex decisions
+- **Prefer refactoring over commenting** - If code needs explaining, consider making it clearer instead
+- **API documentation is required** - Swagger comments for all HTTP endpoints are mandatory
+- **Complex algorithms deserve comments** - Mathematical formulas, business rules, or non-obvious optimizations
+
+Example of useless comment:
+
+1.
+
+```sql
+// Create projects table
+CREATE TABLE projects (
+    id                    UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    name                  TEXT NOT NULL,
+    created_at            TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+```
+
+2.
+
+```go
+// Create test project
+project := CreateTestProject(projectName, user, router)
+```
+
+3.
+
+```go
+// CreateValidLogItems creates valid log items for testing
+func CreateValidLogItems(count int, uniqueID string) []logs_receiving.LogItemRequestDTO {
+```

backend/.cursor/rules/controllers-rule.mdc

@@ -14,42 +14,114 @@ func (c *TasksController) GetAvailableTasks(ctx *gin.Context) ...
 
 3. We document all routes with Swagger in the following format:
 
-// SignIn
-// @Summary Authenticate a user
-// @Description Authenticate a user with email and password
-// @Tags users
-// @Accept json
-// @Produce json
-// @Param request body SignInRequest true "User signin data"
-// @Success 200 {object} SignInResponse
-// @Failure 400
-// @Router /users/signin [post]
+package audit_logs
 
-Do not forget to write docs.
-You can avoid description if it is useless.
-Specify particular acceping \ producing models
+import (
+	"net/http"
 
-4. All controllers should have RegisterRoutes method which receives
-RouterGroup (always put this routes on the top of file under controller definition)
+	user_models "logbull/internal/features/users/models"
 
-Example:
+	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
+)
 
-func (c *OrderController) RegisterRoutes(router *gin.RouterGroup) {
-	router.POST("/bots/users/orders/generate", c.GenerateOrder)
-	router.POST("/bots/users/orders/generate-by-admin", c.GenerateOrderByAdmin)
-	router.GET("/bots/users/orders/mark-as-paid-by-admin", c.MarkOrderAsPaidByAdmin)
-	router.GET("/bots/users/orders/payments-by-bot", c.GetOrderPaymentsByBot)
-	router.GET("/bots/users/orders/payments-by-user", c.GetOrderPaymentsByUser)
-	router.GET("/bots/users/orders/orders-by-user-for-admin", c.GetOrdersByUserForAdmin)
-	router.POST("/bots/users/orders/orders-by-user-for-user", c.GetOrdersByUserForUser)
-	router.POST("/bots/users/orders/order", c.GetOrder)
-	router.POST("/bots/users/orders/cancel-subscription-by-user", c.CancelSubscriptionByUser)
-	router.GET("/bots/users/orders/cancel-subscription-by-admin", c.CancelSubscriptionByAdmin)
-	router.GET(
-		"/bots/users/orders/cancel-subscriptions-by-payment-option",
-		c.CancelSubscriptionsByPaymentOption,
-	)
+type AuditLogController struct {
+	auditLogService *AuditLogService
 }
 
-5. Check that use use valid .Query("param") and .Param("param") methods.
-If route does not have param - use .Query("query")
+func (c *AuditLogController) RegisterRoutes(router *gin.RouterGroup) {
+	// All audit log endpoints require authentication (handled in main.go)
+	auditRoutes := router.Group("/audit-logs")
+
+	auditRoutes.GET("/global", c.GetGlobalAuditLogs)
+	auditRoutes.GET("/users/:userId", c.GetUserAuditLogs)
+}
+
+// GetGlobalAuditLogs
+// @Summary Get global audit logs (ADMIN only)
+// @Description Retrieve all audit logs across the system
+// @Tags audit-logs
+// @Accept json
+// @Produce json
+// @Security BearerAuth
+// @Param limit query int false "Limit number of results" default(100)
+// @Param offset query int false "Offset for pagination" default(0)
+// @Param beforeDate query string false "Filter logs created before this date (RFC3339 format)" format(date-time)
+// @Success 200 {object} GetAuditLogsResponse
+// @Failure 401 {object} map[string]string
+// @Failure 403 {object} map[string]string
+// @Router /audit-logs/global [get]
+func (c *AuditLogController) GetGlobalAuditLogs(ctx *gin.Context) {
+	user, isOk := ctx.MustGet("user").(*user_models.User)
+	if !isOk {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Invalid user type in context"})
+		return
+	}
+
+	request := &GetAuditLogsRequest{}
+	if err := ctx.ShouldBindQuery(request); err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "Invalid query parameters"})
+		return
+	}
+
+	response, err := c.auditLogService.GetGlobalAuditLogs(user, request)
+	if err != nil {
+		if err.Error() == "only administrators can view global audit logs" {
+			ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
+			return
+		}
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to retrieve audit logs"})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, response)
+}
+
+// GetUserAuditLogs
+// @Summary Get user audit logs
+// @Description Retrieve audit logs for a specific user
+// @Tags audit-logs
+// @Accept json
+// @Produce json
+// @Security BearerAuth
+// @Param userId path string true "User ID"
+// @Param limit query int false "Limit number of results" default(100)
+// @Param offset query int false "Offset for pagination" default(0)
+// @Param beforeDate query string false "Filter logs created before this date (RFC3339 format)" format(date-time)
+// @Success 200 {object} GetAuditLogsResponse
+// @Failure 400 {object} map[string]string
+// @Failure 401 {object} map[string]string
+// @Failure 403 {object} map[string]string
+// @Router /audit-logs/users/{userId} [get]
+func (c *AuditLogController) GetUserAuditLogs(ctx *gin.Context) {
+	user, isOk := ctx.MustGet("user").(*user_models.User)
+	if !isOk {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Invalid user type in context"})
+		return
+	}
+
+	userIDStr := ctx.Param("userId")
+	targetUserID, err := uuid.Parse(userIDStr)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "Invalid user ID"})
+		return
+	}
+
+	request := &GetAuditLogsRequest{}
+	if err := ctx.ShouldBindQuery(request); err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "Invalid query parameters"})
+		return
+	}
+
+	response, err := c.auditLogService.GetUserAuditLogs(targetUserID, user, request)
+	if err != nil {
+		if err.Error() == "insufficient permissions to view user audit logs" {
+			ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
+			return
+		}
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to retrieve audit logs"})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, response)
+}

backend/.cursor/rules/crud.mdc

@@ -0,0 +1,655 @@
+---
+alwaysApply: false
+---
+This is example of CRUD:
+
+------ backend/internal/features/audit_logs/controller.go ------
+``````
+package audit_logs
+
+import (
+	"net/http"
+
+	user_models "logbull/internal/features/users/models"
+
+	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
+)
+
+type AuditLogController struct {
+	auditLogService *AuditLogService
+}
+
+func (c *AuditLogController) RegisterRoutes(router *gin.RouterGroup) {
+	// All audit log endpoints require authentication (handled in main.go)
+	auditRoutes := router.Group("/audit-logs")
+
+	auditRoutes.GET("/global", c.GetGlobalAuditLogs)
+	auditRoutes.GET("/users/:userId", c.GetUserAuditLogs)
+}
+
+// GetGlobalAuditLogs
+// @Summary Get global audit logs (ADMIN only)
+// @Description Retrieve all audit logs across the system
+// @Tags audit-logs
+// @Accept json
+// @Produce json
+// @Security BearerAuth
+// @Param limit query int false "Limit number of results" default(100)
+// @Param offset query int false "Offset for pagination" default(0)
+// @Param beforeDate query string false "Filter logs created before this date (RFC3339 format)" format(date-time)
+// @Success 200 {object} GetAuditLogsResponse
+// @Failure 401 {object} map[string]string
+// @Failure 403 {object} map[string]string
+// @Router /audit-logs/global [get]
+func (c *AuditLogController) GetGlobalAuditLogs(ctx *gin.Context) {
+	user, isOk := ctx.MustGet("user").(*user_models.User)
+	if !isOk {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Invalid user type in context"})
+		return
+	}
+
+	request := &GetAuditLogsRequest{}
+	if err := ctx.ShouldBindQuery(request); err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "Invalid query parameters"})
+		return
+	}
+
+	response, err := c.auditLogService.GetGlobalAuditLogs(user, request)
+	if err != nil {
+		if err.Error() == "only administrators can view global audit logs" {
+			ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
+			return
+		}
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to retrieve audit logs"})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, response)
+}
+
+// GetUserAuditLogs
+// @Summary Get user audit logs
+// @Description Retrieve audit logs for a specific user
+// @Tags audit-logs
+// @Accept json
+// @Produce json
+// @Security BearerAuth
+// @Param userId path string true "User ID"
+// @Param limit query int false "Limit number of results" default(100)
+// @Param offset query int false "Offset for pagination" default(0)
+// @Param beforeDate query string false "Filter logs created before this date (RFC3339 format)" format(date-time)
+// @Success 200 {object} GetAuditLogsResponse
+// @Failure 400 {object} map[string]string
+// @Failure 401 {object} map[string]string
+// @Failure 403 {object} map[string]string
+// @Router /audit-logs/users/{userId} [get]
+func (c *AuditLogController) GetUserAuditLogs(ctx *gin.Context) {
+	user, isOk := ctx.MustGet("user").(*user_models.User)
+	if !isOk {
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Invalid user type in context"})
+		return
+	}
+
+	userIDStr := ctx.Param("userId")
+	targetUserID, err := uuid.Parse(userIDStr)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "Invalid user ID"})
+		return
+	}
+
+	request := &GetAuditLogsRequest{}
+	if err := ctx.ShouldBindQuery(request); err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "Invalid query parameters"})
+		return
+	}
+
+	response, err := c.auditLogService.GetUserAuditLogs(targetUserID, user, request)
+	if err != nil {
+		if err.Error() == "insufficient permissions to view user audit logs" {
+			ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
+			return
+		}
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to retrieve audit logs"})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, response)
+}
+
+``````
+------ backend/internal/features/audit_logs/controller_test.go ------
+``````
+package audit_logs
+
+import (
+	"fmt"
+	"net/http"
+	"testing"
+	"time"
+
+	user_enums "logbull/internal/features/users/enums"
+	users_middleware "logbull/internal/features/users/middleware"
+	users_services "logbull/internal/features/users/services"
+	users_testing "logbull/internal/features/users/testing"
+	"logbull/internal/storage"
+	test_utils "logbull/internal/util/testing"
+
+	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_GetGlobalAuditLogs_AdminSucceedsAndMemberGetsForbidden(t *testing.T) {
+	adminUser := users_testing.CreateTestUser(user_enums.UserRoleAdmin)
+	memberUser := users_testing.CreateTestUser(user_enums.UserRoleMember)
+	router := createRouter()
+	service := GetAuditLogService()
+	projectID := uuid.New()
+
+	// Create test logs
+	createAuditLog(service, "Test log with user", &adminUser.UserID, nil)
+	createAuditLog(service, "Test log with project", nil, &projectID)
+	createAuditLog(service, "Test log standalone", nil, nil)
+
+	// Test ADMIN can access global logs
+	var response GetAuditLogsResponse
+	test_utils.MakeGetRequestAndUnmarshal(t, router,
+		"/api/v1/audit-logs/global?limit=10", "Bearer "+adminUser.Token, http.StatusOK, &response)
+
+	assert.GreaterOrEqual(t, len(response.AuditLogs), 3)
+	assert.GreaterOrEqual(t, response.Total, int64(3))
+
+	messages := extractMessages(response.AuditLogs)
+	assert.Contains(t, messages, "Test log with user")
+	assert.Contains(t, messages, "Test log with project")
+	assert.Contains(t, messages, "Test log standalone")
+
+	// Test MEMBER cannot access global logs
+	resp := test_utils.MakeGetRequest(t, router, "/api/v1/audit-logs/global",
+		"Bearer "+memberUser.Token, http.StatusForbidden)
+	assert.Contains(t, string(resp.Body), "only administrators can view global audit logs")
+}
+
+func Test_GetUserAuditLogs_PermissionsEnforcedCorrectly(t *testing.T) {
+	adminUser := users_testing.CreateTestUser(user_enums.UserRoleAdmin)
+	user1 := users_testing.CreateTestUser(user_enums.UserRoleMember)
+	user2 := users_testing.CreateTestUser(user_enums.UserRoleMember)
+	router := createRouter()
+	service := GetAuditLogService()
+	projectID := uuid.New()
+
+	// Create test logs for different users
+	createAuditLog(service, "Test log user1 first", &user1.UserID, nil)
+	createAuditLog(service, "Test log user1 second", &user1.UserID, &projectID)
+	createAuditLog(service, "Test log user2 first", &user2.UserID, nil)
+	createAuditLog(service, "Test log user2 second", &user2.UserID, &projectID)
+	createAuditLog(service, "Test project log", nil, &projectID)
+
+	// Test ADMIN can view any user's logs
+	var user1Response GetAuditLogsResponse
+	test_utils.MakeGetRequestAndUnmarshal(t, router,
+		fmt.Sprintf("/api/v1/audit-logs/users/%s?limit=10", user1.UserID.String()),
+		"Bearer "+adminUser.Token, http.StatusOK, &user1Response)
+
+	assert.Equal(t, 2, len(user1Response.AuditLogs))
+	messages := extractMessages(user1Response.AuditLogs)
+	assert.Contains(t, messages, "Test log user1 first")
+	assert.Contains(t, messages, "Test log user1 second")
+
+	// Test user can view own logs
+	var ownLogsResponse GetAuditLogsResponse
+	test_utils.MakeGetRequestAndUnmarshal(t, router,
+		fmt.Sprintf("/api/v1/audit-logs/users/%s", user2.UserID.String()),
+		"Bearer "+user2.Token, http.StatusOK, &ownLogsResponse)
+	assert.Equal(t, 2, len(ownLogsResponse.AuditLogs))
+
+	// Test user cannot view other user's logs
+	resp := test_utils.MakeGetRequest(t, router,
+		fmt.Sprintf("/api/v1/audit-logs/users/%s", user1.UserID.String()),
+		"Bearer "+user2.Token, http.StatusForbidden)
+
+	assert.Contains(t, string(resp.Body), "insufficient permissions")
+}
+
+func Test_FilterAuditLogsByTime_ReturnsOnlyLogsBeforeDate(t *testing.T) {
+	adminUser := users_testing.CreateTestUser(user_enums.UserRoleAdmin)
+	router := createRouter()
+	service := GetAuditLogService()
+	db := storage.GetDb()
+	baseTime := time.Now().UTC()
+
+	// Create logs with different timestamps
+	createTimedLog(db, &adminUser.UserID, "Test old log", baseTime.Add(-2*time.Hour))
+	createTimedLog(db, &adminUser.UserID, "Test recent log", baseTime.Add(-30*time.Minute))
+	createAuditLog(service, "Test current log", &adminUser.UserID, nil)
+
+	// Test filtering - get logs before 1 hour ago
+	beforeTime := baseTime.Add(-1 * time.Hour)
+	var filteredResponse GetAuditLogsResponse
+	test_utils.MakeGetRequestAndUnmarshal(t, router,
+		fmt.Sprintf("/api/v1/audit-logs/global?beforeDate=%s", beforeTime.Format(time.RFC3339)),
+		"Bearer "+adminUser.Token, http.StatusOK, &filteredResponse)
+
+	// Verify only old log is returned
+	messages := extractMessages(filteredResponse.AuditLogs)
+	assert.Contains(t, messages, "Test old log")
+	assert.NotContains(t, messages, "Test recent log")
+	assert.NotContains(t, messages, "Test current log")
+
+	// Test without filter - should get all logs
+	var allResponse GetAuditLogsResponse
+	test_utils.MakeGetRequestAndUnmarshal(t, router, "/api/v1/audit-logs/global",
+		"Bearer "+adminUser.Token, http.StatusOK, &allResponse)
+	assert.GreaterOrEqual(t, len(allResponse.AuditLogs), 3)
+}
+
+func createRouter() *gin.Engine {
+	gin.SetMode(gin.TestMode)
+	router := gin.New()
+	SetupDependencies()
+
+	v1 := router.Group("/api/v1")
+	protected := v1.Group("").Use(users_middleware.AuthMiddleware(users_services.GetUserService()))
+	GetAuditLogController().RegisterRoutes(protected.(*gin.RouterGroup))
+
+	return router
+}
+
+``````
+------ backend/internal/features/audit_logs/di.go ------
+``````
+package audit_logs
+
+import (
+	users_services "logbull/internal/features/users/services"
+	"logbull/internal/util/logger"
+)
+
+var auditLogRepository = &AuditLogRepository{}
+var auditLogService = &AuditLogService{
+	auditLogRepository: auditLogRepository,
+	logger:             logger.GetLogger(),
+}
+var auditLogController = &AuditLogController{
+	auditLogService: auditLogService,
+}
+
+func GetAuditLogService() *AuditLogService {
+	return auditLogService
+}
+
+func GetAuditLogController() *AuditLogController {
+	return auditLogController
+}
+
+func SetupDependencies() {
+	users_services.GetUserService().SetAuditLogWriter(auditLogService)
+	users_services.GetSettingsService().SetAuditLogWriter(auditLogService)
+	users_services.GetManagementService().SetAuditLogWriter(auditLogService)
+}
+
+``````
+------ backend/internal/features/audit_logs/dto.go ------
+``````
+package audit_logs
+
+import "time"
+
+type GetAuditLogsRequest struct {
+	Limit      int        `form:"limit"      json:"limit"`
+	Offset     int        `form:"offset"     json:"offset"`
+	BeforeDate *time.Time `form:"beforeDate" json:"beforeDate"`
+}
+
+type GetAuditLogsResponse struct {
+	AuditLogs []*AuditLog `json:"auditLogs"`
+	Total     int64       `json:"total"`
+	Limit     int         `json:"limit"`
+	Offset    int         `json:"offset"`
+}
+
+``````
+------ backend/internal/features/audit_logs/models.go ------
+``````
+package audit_logs
+
+import (
+	"time"
+
+	"github.com/google/uuid"
+)
+
+type AuditLog struct {
+	ID        uuid.UUID  `json:"id"        gorm:"column:id"`
+	UserID    *uuid.UUID `json:"userId"    gorm:"column:user_id"`
+	ProjectID *uuid.UUID `json:"projectId" gorm:"column:project_id"`
+	Message   string     `json:"message"   gorm:"column:message"`
+	CreatedAt time.Time  `json:"createdAt" gorm:"column:created_at"`
+}
+
+func (AuditLog) TableName() string {
+	return "audit_logs"
+}
+
+``````
+------ backend/internal/features/audit_logs/repository.go ------
+``````
+package audit_logs
+
+import (
+	"logbull/internal/storage"
+	"time"
+
+	"github.com/google/uuid"
+)
+
+type AuditLogRepository struct{}
+
+func (r *AuditLogRepository) Create(auditLog *AuditLog) error {
+	if auditLog.ID == uuid.Nil {
+		auditLog.ID = uuid.New()
+	}
+
+	return storage.GetDb().Create(auditLog).Error
+}
+
+func (r *AuditLogRepository) GetGlobal(limit, offset int, beforeDate *time.Time) ([]*AuditLog, error) {
+	var auditLogs []*AuditLog
+
+	query := storage.GetDb().Order("created_at DESC")
+
+	if beforeDate != nil {
+		query = query.Where("created_at < ?", *beforeDate)
+	}
+
+	err := query.
+		Limit(limit).
+		Offset(offset).
+		Find(&auditLogs).Error
+
+	return auditLogs, err
+}
+
+func (r *AuditLogRepository) GetByUser(
+	userID uuid.UUID,
+	limit, offset int,
+	beforeDate *time.Time,
+) ([]*AuditLog, error) {
+	var auditLogs []*AuditLog
+
+	query := storage.GetDb().
+		Where("user_id = ?", userID).
+		Order("created_at DESC")
+
+	if beforeDate != nil {
+		query = query.Where("created_at < ?", *beforeDate)
+	}
+
+	err := query.
+		Limit(limit).
+		Offset(offset).
+		Find(&auditLogs).Error
+
+	return auditLogs, err
+}
+
+func (r *AuditLogRepository) GetByProject(
+	projectID uuid.UUID,
+	limit, offset int,
+	beforeDate *time.Time,
+) ([]*AuditLog, error) {
+	var auditLogs []*AuditLog
+
+	query := storage.GetDb().
+		Where("project_id = ?", projectID).
+		Order("created_at DESC")
+
+	if beforeDate != nil {
+		query = query.Where("created_at < ?", *beforeDate)
+	}
+
+	err := query.
+		Limit(limit).
+		Offset(offset).
+		Find(&auditLogs).Error
+
+	return auditLogs, err
+}
+
+func (r *AuditLogRepository) CountGlobal(beforeDate *time.Time) (int64, error) {
+	var count int64
+	query := storage.GetDb().Model(&AuditLog{})
+
+	if beforeDate != nil {
+		query = query.Where("created_at < ?", *beforeDate)
+	}
+
+	err := query.Count(&count).Error
+	return count, err
+}
+
+``````
+------ backend/internal/features/audit_logs/service.go ------
+``````
+package audit_logs
+
+import (
+	"errors"
+	"log/slog"
+	"time"
+
+	user_enums "logbull/internal/features/users/enums"
+	user_models "logbull/internal/features/users/models"
+
+	"github.com/google/uuid"
+)
+
+type AuditLogService struct {
+	auditLogRepository *AuditLogRepository
+	logger             *slog.Logger
+}
+
+func (s *AuditLogService) WriteAuditLog(
+	message string,
+	userID *uuid.UUID,
+	projectID *uuid.UUID,
+) {
+	auditLog := &AuditLog{
+		UserID:    userID,
+		ProjectID: projectID,
+		Message:   message,
+		CreatedAt: time.Now().UTC(),
+	}
+
+	err := s.auditLogRepository.Create(auditLog)
+	if err != nil {
+		s.logger.Error("failed to create audit log", "error", err)
+		return
+	}
+}
+
+func (s *AuditLogService) CreateAuditLog(auditLog *AuditLog) error {
+	return s.auditLogRepository.Create(auditLog)
+}
+
+func (s *AuditLogService) GetGlobalAuditLogs(
+	user *user_models.User,
+	request *GetAuditLogsRequest,
+) (*GetAuditLogsResponse, error) {
+	if user.Role != user_enums.UserRoleAdmin {
+		return nil, errors.New("only administrators can view global audit logs")
+	}
+
+	limit := request.Limit
+	if limit <= 0 || limit > 1000 {
+		limit = 100
+	}
+
+	offset := max(request.Offset, 0)
+
+	auditLogs, err := s.auditLogRepository.GetGlobal(limit, offset, request.BeforeDate)
+	if err != nil {
+		return nil, err
+	}
+
+	total, err := s.auditLogRepository.CountGlobal(request.BeforeDate)
+	if err != nil {
+		return nil, err
+	}
+
+	return &GetAuditLogsResponse{
+		AuditLogs: auditLogs,
+		Total:     total,
+		Limit:     limit,
+		Offset:    offset,
+	}, nil
+}
+
+func (s *AuditLogService) GetUserAuditLogs(
+	targetUserID uuid.UUID,
+	user *user_models.User,
+	request *GetAuditLogsRequest,
+) (*GetAuditLogsResponse, error) {
+	// Users can view their own logs, ADMIN can view any user's logs
+	if user.Role != user_enums.UserRoleAdmin && user.ID != targetUserID {
+		return nil, errors.New("insufficient permissions to view user audit logs")
+	}
+
+	limit := request.Limit
+	if limit <= 0 || limit > 1000 {
+		limit = 100
+	}
+
+	offset := max(request.Offset, 0)
+
+	auditLogs, err := s.auditLogRepository.GetByUser(targetUserID, limit, offset, request.BeforeDate)
+	if err != nil {
+		return nil, err
+	}
+
+	return &GetAuditLogsResponse{
+		AuditLogs: auditLogs,
+		Total:     int64(len(auditLogs)),
+		Limit:     limit,
+		Offset:    offset,
+	}, nil
+}
+
+func (s *AuditLogService) GetProjectAuditLogs(
+	projectID uuid.UUID,
+	request *GetAuditLogsRequest,
+) (*GetAuditLogsResponse, error) {
+	limit := request.Limit
+	if limit <= 0 || limit > 1000 {
+		limit = 100
+	}
+
+	offset := max(request.Offset, 0)
+
+	auditLogs, err := s.auditLogRepository.GetByProject(projectID, limit, offset, request.BeforeDate)
+	if err != nil {
+		return nil, err
+	}
+
+	return &GetAuditLogsResponse{
+		AuditLogs: auditLogs,
+		Total:     int64(len(auditLogs)),
+		Limit:     limit,
+		Offset:    offset,
+	}, nil
+}
+
+``````
+------ backend/internal/features/audit_logs/service_test.go ------
+``````
+package audit_logs
+
+import (
+	"testing"
+	"time"
+
+	user_enums "logbull/internal/features/users/enums"
+	users_testing "logbull/internal/features/users/testing"
+
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+	"gorm.io/gorm"
+)
+
+func Test_AuditLogs_ProjectSpecificLogs(t *testing.T) {
+	service := GetAuditLogService()
+	user1 := users_testing.CreateTestUser(user_enums.UserRoleMember)
+	user2 := users_testing.CreateTestUser(user_enums.UserRoleMember)
+	project1ID, project2ID := uuid.New(), uuid.New()
+
+	// Create test logs for projects
+	createAuditLog(service, "Test project1 log first", &user1.UserID, &project1ID)
+	createAuditLog(service, "Test project1 log second", &user2.UserID, &project1ID)
+	createAuditLog(service, "Test project2 log first", &user1.UserID, &project2ID)
+	createAuditLog(service, "Test project2 log second", &user2.UserID, &project2ID)
+	createAuditLog(service, "Test no project log", &user1.UserID, nil)
+
+	request := &GetAuditLogsRequest{Limit: 10, Offset: 0}
+
+	// Test project 1 logs
+	project1Response, err := service.GetProjectAuditLogs(project1ID, request)
+	assert.NoError(t, err)
+	assert.Equal(t, 2, len(project1Response.AuditLogs))
+
+	messages := extractMessages(project1Response.AuditLogs)
+	assert.Contains(t, messages, "Test project1 log first")
+	assert.Contains(t, messages, "Test project1 log second")
+	for _, log := range project1Response.AuditLogs {
+		assert.Equal(t, &project1ID, log.ProjectID)
+	}
+
+	// Test project 2 logs
+	project2Response, err := service.GetProjectAuditLogs(project2ID, request)
+	assert.NoError(t, err)
+	assert.Equal(t, 2, len(project2Response.AuditLogs))
+
+	messages2 := extractMessages(project2Response.AuditLogs)
+	assert.Contains(t, messages2, "Test project2 log first")
+	assert.Contains(t, messages2, "Test project2 log second")
+
+	// Test pagination
+	limitedResponse, err := service.GetProjectAuditLogs(project1ID,
+		&GetAuditLogsRequest{Limit: 1, Offset: 0})
+	assert.NoError(t, err)
+	assert.Equal(t, 1, len(limitedResponse.AuditLogs))
+	assert.Equal(t, 1, limitedResponse.Limit)
+
+	// Test beforeDate filter
+	beforeTime := time.Now().UTC().Add(-1 * time.Minute)
+	filteredResponse, err := service.GetProjectAuditLogs(project1ID,
+		&GetAuditLogsRequest{Limit: 10, BeforeDate: &beforeTime})
+	assert.NoError(t, err)
+	for _, log := range filteredResponse.AuditLogs {
+		assert.True(t, log.CreatedAt.Before(beforeTime))
+	}
+}
+
+func createAuditLog(service *AuditLogService, message string, userID, projectID *uuid.UUID) {
+	service.WriteAuditLog(message, userID, projectID)
+}
+
+func extractMessages(logs []*AuditLog) []string {
+	messages := make([]string, len(logs))
+	for i, log := range logs {
+		messages[i] = log.Message
+	}
+	return messages
+}
+
+func createTimedLog(db *gorm.DB, userID *uuid.UUID, message string, createdAt time.Time) {
+	log := &AuditLog{
+		ID:        uuid.New(),
+		UserID:    userID,
+		Message:   message,
+		CreatedAt: createdAt,
+	}
+	db.Create(log)
+}
+
+``````

backend/.cursor/rules/refactor.mdc

@@ -0,0 +1,12 @@
+---
+description:
+globs:
+alwaysApply: true
+---
+
+When applying changes, do not forget to refactor old code.
+
+You can shortify, make more readable, improve code quality, etc.
+Common logic can be extracted to functions, constants, files, etc.
+
+After each large change with more than ~50-100 lines of code - always run `make lint` (from backend root folder).

backend/.cursor/rules/tests.mdc

@@ -1,12 +1,147 @@
 ---
-description: 
-globs: 
+description:
+globs:
 alwaysApply: true
 ---
-Write tests names in the format:
 
-Test_WhatWeDo_WhatWeExpect
+After writing tests, always launch them and verify that they pass.
 
-Example:
-- Test_TestConnection_ConnectionSucceeds
-- Test_SaveNewStorage_StorageReturnedViaGet
+## Test Naming Format
+
+Use these naming patterns:
+
+- `Test_WhatWeDo_WhatWeExpect`
+- `Test_WhatWeDo_WhichConditions_WhatWeExpect`
+
+## Examples from Real Codebase:
+
+- `Test_CreateApiKey_WhenUserIsProjectOwner_ApiKeyCreated`
+- `Test_UpdateProject_WhenUserIsProjectAdmin_ProjectUpdated`
+- `Test_DeleteApiKey_WhenUserIsProjectMember_ReturnsForbidden`
+- `Test_GetProjectAuditLogs_WithDifferentUserRoles_EnforcesPermissionsCorrectly`
+- `Test_ProjectLifecycleE2E_CompletesSuccessfully`
+
+## Testing Philosophy
+
+**Prefer Controllers Over Unit Tests:**
+
+- Test through HTTP endpoints via controllers whenever possible
+- Avoid testing repositories, services in isolation - test via API instead
+- Only use unit tests for complex model logic when no API exists
+- Name test files `controller_test.go` or `service_test.go`, not `integration_test.go`
+
+**Extract Common Logic to Testing Utilities:**
+
+- Create `testing.go` or `testing/testing.go` files for shared test utilities
+- Extract router creation, user setup, models creation helpers (in API, not just structs creation)
+- Reuse common patterns across different test files
+
+**Refactor Existing Tests:**
+
+- When working with existing tests, always look for opportunities to refactor and improve
+- Extract repetitive setup code to common utilities
+- Simplify complex tests by breaking them into smaller, focused tests
+- Replace inline test data creation with reusable helper functions
+- Consolidate similar test patterns across different test files
+- Make tests more readable and maintainable for other developers
+
+## Testing Utilities Structure
+
+**Create `testing.go` or `testing/testing.go` files with common utilities:**
+
+```go
+package projects_testing
+
+// CreateTestRouter creates unified router for all controllers
+func CreateTestRouter(controllers ...ControllerInterface) *gin.Engine {
+	gin.SetMode(gin.TestMode)
+	router := gin.New()
+	v1 := router.Group("/api/v1")
+	protected := v1.Group("").Use(users_middleware.AuthMiddleware(users_services.GetUserService()))
+
+	for _, controller := range controllers {
+		if routerGroup, ok := protected.(*gin.RouterGroup); ok {
+			controller.RegisterRoutes(routerGroup)
+		}
+	}
+	return router
+}
+
+// CreateTestProjectViaAPI creates project through HTTP API
+func CreateTestProjectViaAPI(name string, owner *users_dto.SignInResponseDTO, router *gin.Engine) (*projects_models.Project, string) {
+	request := projects_dto.CreateProjectRequestDTO{Name: name}
+	w := MakeAPIRequest(router, "POST", "/api/v1/projects", "Bearer "+owner.Token, request)
+	// Handle response...
+	return project, owner.Token
+}
+
+// AddMemberToProject adds member via API call
+func AddMemberToProject(project *projects_models.Project, member *users_dto.SignInResponseDTO, role users_enums.ProjectRole, ownerToken string, router *gin.Engine) {
+	// Implementation...
+}
+```
+
+## Controller Test Examples
+
+**Permission-based testing:**
+
+```go
+func Test_CreateApiKey_WhenUserIsProjectOwner_ApiKeyCreated(t *testing.T) {
+	router := CreateApiKeyTestRouter(GetProjectController(), GetMembershipController())
+	owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+	project, _ := projects_testing.CreateTestProjectViaAPI("Test Project", owner, router)
+
+	request := CreateApiKeyRequestDTO{Name: "Test API Key"}
+	var response ApiKey
+	test_utils.MakePostRequestAndUnmarshal(t, router, "/api/v1/projects/api-keys/"+project.ID.String(), "Bearer "+owner.Token, request, http.StatusOK, &response)
+
+	assert.Equal(t, "Test API Key", response.Name)
+	assert.NotEmpty(t, response.Token)
+}
+```
+
+**Cross-project security testing:**
+
+```go
+func Test_UpdateApiKey_WithApiKeyFromDifferentProject_ReturnsBadRequest(t *testing.T) {
+	router := CreateApiKeyTestRouter(GetProjectController(), GetMembershipController())
+	owner1 := users_testing.CreateTestUser(users_enums.UserRoleMember)
+	owner2 := users_testing.CreateTestUser(users_enums.UserRoleMember)
+	project1, _ := projects_testing.CreateTestProjectViaAPI("Project 1", owner1, router)
+	project2, _ := projects_testing.CreateTestProjectViaAPI("Project 2", owner2, router)
+
+	apiKey := CreateTestApiKey("Cross Project Key", project1.ID, owner1.Token, router)
+
+	// Try to update via different project endpoint
+	request := UpdateApiKeyRequestDTO{Name: &"Hacked Key"}
+	resp := test_utils.MakePutRequest(t, router, "/api/v1/projects/api-keys/"+project2.ID.String()+"/"+apiKey.ID.String(), "Bearer "+owner2.Token, request, http.StatusBadRequest)
+
+	assert.Contains(t, string(resp.Body), "API key does not belong to this project")
+}
+```
+
+**E2E lifecycle testing:**
+
+```go
+func Test_ProjectLifecycleE2E_CompletesSuccessfully(t *testing.T) {
+	router := projects_testing.CreateTestRouter(GetProjectController(), GetMembershipController())
+
+	// 1. Create project
+	owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+	project := projects_testing.CreateTestProject("E2E Project", owner, router)
+
+	// 2. Add member
+	member := users_testing.CreateTestUser(users_enums.UserRoleMember)
+	projects_testing.AddMemberToProject(project, member, users_enums.ProjectRoleMember, owner.Token, router)
+
+	// 3. Promote to admin
+	projects_testing.ChangeMemberRole(project, member.UserID, users_enums.ProjectRoleAdmin, owner.Token, router)
+
+	// 4. Transfer ownership
+	projects_testing.TransferProjectOwnership(project, member.UserID, owner.Token, router)
+
+	// 5. Verify new owner can manage project
+	finalProject := projects_testing.GetProject(project.ID, member.Token, router)
+	assert.Equal(t, project.ID, finalProject.ID)
+}
+```

backend/.env.development.example

@@ -22,6 +22,9 @@ TEST_POSTGRES_14_PORT=5002
 TEST_POSTGRES_15_PORT=5003
 TEST_POSTGRES_16_PORT=5004
 TEST_POSTGRES_17_PORT=5005
+TEST_POSTGRES_18_PORT=5006
 # testing S3
 TEST_MINIO_PORT=9000
-TEST_MINIO_CONSOLE_PORT=9001
+TEST_MINIO_CONSOLE_PORT=9001
+# testing NAS
+TEST_NAS_PORT=7006

backend/.env.production.example

@@ -5,9 +5,9 @@ DEV_DB_PASSWORD=Q1234567
 #app
 ENV_MODE=production
 # db
-DATABASE_DSN=host=postgresus-db user=postgres password=Q1234567 dbname=postgresus port=5437 sslmode=disable
-DATABASE_URL=postgres://postgres:Q1234567@postgresus-db:5437/postgresus?sslmode=disable
+DATABASE_DSN=host=localhost user=postgres password=Q1234567 dbname=postgresus port=5437 sslmode=disable
+DATABASE_URL=postgres://postgres:Q1234567@localhost:5437/postgresus?sslmode=disable
 # migrations
 GOOSE_DRIVER=postgres
-GOOSE_DBSTRING=postgres://postgres:Q1234567@postgresus-db:5437/postgresus?sslmode=disable
+GOOSE_DBSTRING=postgres://postgres:Q1234567@localhost:5437/postgresus?sslmode=disable
 GOOSE_MIGRATION_DIR=./migrations

backend/.gitignore

@@ -11,4 +11,5 @@ swagger/swagger.json
 swagger/swagger.yaml
 postgresus-backend.exe
 ui/build/*
-pgdata-for-restore/
+pgdata-for-restore/
+temp/

backend/.pre-commit-config.yaml

@@ -1,15 +0,0 @@
-repos:
-  - repo: local
-    hooks:
-      - id: golangci-lint-fmt
-        name: Format Go Code using golangci-lint fmt
-        entry: golangci-lint fmt ./...
-        language: system
-        types: [go]
-
-      - id: golangci-lint-run
-        name: Run golangci-lint for static analysis
-        entry: golangci-lint run
-        language: system
-        types: [go]
-        pass_filenames: false

backend/Makefile

@@ -0,0 +1,20 @@
+run:
+	go run cmd/main.go
+
+test:
+	go test -p=1 -count=1 -failfast .\internal\...
+
+lint:
+	golangci-lint fmt && golangci-lint run
+
+migration-create:
+	goose create $(name) sql
+
+migration-up:
+	goose up
+
+migration-down:
+	goose down
+
+swagger:
+	swag init -g ./cmd/main.go -o swagger

backend/README.md

@@ -9,44 +9,39 @@ instead of postgresus-db from docker-compose.yml in the root folder.
 
 # Run
 
-To build:
-
-> go build /cmd/main.go
-
 To run:
 
-> go run /cmd/main.go
+> make run
 
 To run tests:
 
-> go test ./internal/... 
+> make test
 
 Before commit (make sure `golangci-lint` is installed):
 
-> golangci-lint fmt
-> golangci-lint run
+> make lint
 
 # Migrations
 
 To create migration:
 
-> goose create MIGRATION_NAME sql
+> make migration-create name=MIGRATION_NAME
 
 To run migrations:
 
-> goose up
+> make migration-up
 
 If latest migration failed:
 
 To rollback on migration:
 
-> goose down
+> make migration-down
 
 # Swagger
 
 To generate swagger docs:
 
-> swag init -g .\cmd\main.go -o swagger
+> make swagger
 
 Swagger URL is:
 

backend/cmd/main.go

@@ -31,6 +31,7 @@ import (
 	_ "postgresus-backend/swagger" // swagger docs
 
 	"github.com/gin-contrib/cors"
+	"github.com/gin-contrib/gzip"
 	"github.com/gin-gonic/gin"
 	swaggerFiles "github.com/swaggo/files"
 	ginSwagger "github.com/swaggo/gin-swagger"
@@ -49,6 +50,17 @@ func main() {
 
 	runMigrations(log)
 
+	// create directories that used for backups and restore
+	err := files_utils.EnsureDirectories([]string{
+		config.GetEnv().TempFolder,
+		config.GetEnv().DataFolder,
+	})
+
+	if err != nil {
+		log.Error("Failed to ensure directories", "error", err)
+		os.Exit(1)
+	}
+
 	// Handle password reset if flag is provided
 	newPassword := flag.String("new-password", "", "Set a new password for the user")
 	flag.Parse()
@@ -61,6 +73,15 @@ func main() {
 	gin.SetMode(gin.ReleaseMode)
 	ginApp := gin.Default()
 
+	// Add GZIP compression middleware
+	ginApp.Use(gzip.Gzip(
+		gzip.DefaultCompression,
+		// Don't compress already compressed files
+		gzip.WithExcludedExtensions(
+			[]string{".png", ".gif", ".jpeg", ".jpg", ".ico", ".svg", ".pdf", ".mp4"},
+		),
+	))
+
 	enableCors(ginApp)
 	setUpRoutes(ginApp)
 	setUpDependencies()
@@ -153,7 +174,6 @@ func setUpRoutes(r *gin.Engine) {
 }
 
 func setUpDependencies() {
-	backups.SetupDependencies()
 	backups.SetupDependencies()
 	restores.SetupDependencies()
 	healthcheck_config.SetupDependencies()
@@ -176,7 +196,7 @@ func runBackgroundTasks(log *slog.Logger) {
 	})
 
 	go runWithPanicLogging(log, "healthcheck attempt background service", func() {
-		healthcheck_attempt.GetHealthcheckAttemptBackgroundService().RunBackgroundTasks()
+		healthcheck_attempt.GetHealthcheckAttemptBackgroundService().Run()
 	})
 }
 

backend/docker-compose.yml.example

@@ -86,3 +86,30 @@ services:
       - POSTGRES_PASSWORD=testpassword
     container_name: test-postgres-17
     shm_size: 1gb
+
+  test-postgres-18:
+    image: postgres:18
+    ports:
+      - "${TEST_POSTGRES_18_PORT}:5432"
+    environment:
+      - POSTGRES_DB=testdb
+      - POSTGRES_USER=testuser
+      - POSTGRES_PASSWORD=testpassword
+    container_name: test-postgres-18
+    shm_size: 1gb
+
+  # Test NAS server (Samba)
+  test-nas:
+    image: dperson/samba:latest
+    ports:
+      - "${TEST_NAS_PORT:-445}:445"
+    environment:
+      - USERID=1000
+      - GROUPID=1000
+    volumes:
+      - ./temp/nas:/shared
+    command: >
+      -u "testuser;testpassword"
+      -s "backups;/shared;yes;no;no;testuser"
+      -p
+    container_name: test-nas

backend/go.mod

@@ -4,6 +4,7 @@ go 1.23.3
 
 require (
 	github.com/gin-contrib/cors v1.7.5
+	github.com/gin-contrib/gzip v1.2.3
 	github.com/gin-gonic/gin v1.10.0
 	github.com/golang-jwt/jwt/v4 v4.5.2
 	github.com/google/uuid v1.6.0
@@ -19,6 +20,7 @@ require (
 	github.com/swaggo/gin-swagger v1.6.0
 	github.com/swaggo/swag v1.16.4
 	golang.org/x/crypto v0.39.0
+	golang.org/x/time v0.12.0
 	gorm.io/driver/postgres v1.5.11
 	gorm.io/gorm v1.26.1
 )
@@ -27,9 +29,11 @@ require (
 	cloud.google.com/go/auth v0.16.2 // indirect
 	cloud.google.com/go/auth/oauth2adapt v0.2.8 // indirect
 	cloud.google.com/go/compute/metadata v0.7.0 // indirect
+	github.com/geoffgarside/ber v1.1.0 // indirect
 	github.com/google/s2a-go v0.1.9 // indirect
 	github.com/googleapis/enterprise-certificate-proxy v0.3.6 // indirect
 	github.com/googleapis/gax-go/v2 v2.14.2 // indirect
+	github.com/hirochachacha/go-smb2 v1.1.0
 	google.golang.org/genproto/googleapis/api v0.0.0-20250528174236-200df99c418a // indirect
 	google.golang.org/genproto/googleapis/rpc v0.0.0-20250603155806-513f23925822 // indirect
 	google.golang.org/grpc v1.73.0 // indirect

backend/go.sum

@@ -35,10 +35,12 @@ github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2
 github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U=
 github.com/gabriel-vasile/mimetype v1.4.9 h1:5k+WDwEsD9eTLL8Tz3L0VnmVh9QxGjRmjBvAG7U/oYY=
 github.com/gabriel-vasile/mimetype v1.4.9/go.mod h1:WnSQhFKJuBlRyLiKohA/2DtIlPFAbguNaG7QCHcyGok=
+github.com/geoffgarside/ber v1.1.0 h1:qTmFG4jJbwiSzSXoNJeHcOprVzZ8Ulde2Rrrifu5U9w=
+github.com/geoffgarside/ber v1.1.0/go.mod h1:jVPKeCbj6MvQZhwLYsGwaGI52oUorHoHKNecGT85ZCc=
 github.com/gin-contrib/cors v1.7.5 h1:cXC9SmofOrRg0w9PigwGlHG3ztswH6bqq4vJVXnvYMk=
 github.com/gin-contrib/cors v1.7.5/go.mod h1:4q3yi7xBEDDWKapjT2o1V7mScKDDr8k+jZ0fSquGoy0=
-github.com/gin-contrib/gzip v0.0.6 h1:NjcunTcGAj5CO1gn4N8jHOSIeRFHIbn51z6K+xaN4d4=
-github.com/gin-contrib/gzip v0.0.6/go.mod h1:QOJlmV2xmayAjkNS2Y8NQsMneuRShOU/kjovCXNuzzk=
+github.com/gin-contrib/gzip v1.2.3 h1:dAhT722RuEG330ce2agAs75z7yB+NKvX/ZM1r8w0u2U=
+github.com/gin-contrib/gzip v1.2.3/go.mod h1:ad72i4Bzmaypk8M762gNXa2wkxxjbz0icRNnuLJ9a/c=
 github.com/gin-contrib/sse v1.1.0 h1:n0w2GMuUpWDVp7qSpvze6fAu9iRxJY4Hmj6AmBOU05w=
 github.com/gin-contrib/sse v1.1.0/go.mod h1:hxRZ5gVpWMT7Z0B0gSNYqqsSCNIJMjzvm6fqCz9vjwM=
 github.com/gin-gonic/gin v1.10.0 h1:nTuyha1TYqgedzytsKYqna+DfLos46nTv2ygFy86HFU=
@@ -91,6 +93,8 @@ github.com/googleapis/enterprise-certificate-proxy v0.3.6 h1:GW/XbdyBFQ8Qe+YAmFU
 github.com/googleapis/enterprise-certificate-proxy v0.3.6/go.mod h1:MkHOF77EYAE7qfSuSS9PU6g4Nt4e11cnsDUowfwewLA=
 github.com/googleapis/gax-go/v2 v2.14.2 h1:eBLnkZ9635krYIPD+ag1USrOAI0Nr0QYF3+/3GqO0k0=
 github.com/googleapis/gax-go/v2 v2.14.2/go.mod h1:ON64QhlJkhVtSqp4v1uaK92VyZ2gmvDQsweuyLV+8+w=
+github.com/hirochachacha/go-smb2 v1.1.0 h1:b6hs9qKIql9eVXAiN0M2wSFY5xnhbHAQoCwRKbaRTZI=
+github.com/hirochachacha/go-smb2 v1.1.0/go.mod h1:8F1A4d5EZzrGu5R7PU163UcMRDJQl4FtcxjBfsY8TZE=
 github.com/ilyakaznacheev/cleanenv v1.5.0 h1:0VNZXggJE2OYdXE87bfSSwGxeiGt9moSR2lOrsHHvr4=
 github.com/ilyakaznacheev/cleanenv v1.5.0/go.mod h1:a5aDzaJrLCQZsazHol1w8InnDcOX0OColm64SlIi6gk=
 github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
@@ -210,12 +214,14 @@ go.opentelemetry.io/otel/trace v1.36.0/go.mod h1:gQ+OnDZzrybY4k4seLzPAWNwVBBVlF2
 golang.org/x/arch v0.17.0 h1:4O3dfLzd+lQewptAHqjewQZQDyEdejz3VwgeYwkZneU=
 golang.org/x/arch v0.17.0/go.mod h1:bdwinDaKcfZUGpH09BB7ZmOfhalA8lQdzl62l8gGWsk=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20200728195943-123391ffb6de/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.39.0 h1:SHs+kF4LP+f+p14esP5jAoDpHU8Gu/v9lFRK6IT5imM=
 golang.org/x/crypto v0.39.0/go.mod h1:L+Xg3Wf6HoL4Bn4238Z6ft6KfEpN0tJGo53AAPC632U=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
 golang.org/x/mod v0.25.0 h1:n7a+ZbQKQA/Ysbyb0/6IbB1H/X41mKgbhfv7AfG/44w=
 golang.org/x/mod v0.25.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20210421230115-4e50805a0758/go.mod h1:72T/g9IO56b78aLF+1Kcs5dz7/ng1VjMUvfKvpfy+jM=
@@ -230,6 +236,7 @@ golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJ
 golang.org/x/sync v0.15.0 h1:KWH3jNZsfyT6xfAfKiz6MRNmd46ByHDYaZ7KSkCtdW8=
 golang.org/x/sync v0.15.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201204225414-ed752295db88/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -252,6 +259,8 @@ golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
 golang.org/x/text v0.26.0 h1:P42AVeLghgTYr4+xUnTRKDMqpar+PtX7KWuNQL21L8M=
 golang.org/x/text v0.26.0/go.mod h1:QK15LZJUUQVJxhz7wXgxSy/CJaTFjd0G+YLonydOVQA=
+golang.org/x/time v0.12.0 h1:ScB/8o8olJvc+CQPWrK3fPZNfh7qgwCrY0zJmoEQLSE=
+golang.org/x/time v0.12.0/go.mod h1:CDIdPxbZBQxdj6cxyCIdrNogrJKMJ7pr37NYpMcMDSg=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=

backend/internal/config/config.go

@@ -38,9 +38,12 @@ type EnvVariables struct {
 	TestPostgres15Port string `env:"TEST_POSTGRES_15_PORT"`
 	TestPostgres16Port string `env:"TEST_POSTGRES_16_PORT"`
 	TestPostgres17Port string `env:"TEST_POSTGRES_17_PORT"`
+	TestPostgres18Port string `env:"TEST_POSTGRES_18_PORT"`
 
 	TestMinioPort        string `env:"TEST_MINIO_PORT"`
 	TestMinioConsolePort string `env:"TEST_MINIO_CONSOLE_PORT"`
+
+	TestNASPort string `env:"TEST_NAS_PORT"`
 }
 
 var (
@@ -152,6 +155,10 @@ func loadEnvVariables() {
 			log.Error("TEST_POSTGRES_17_PORT is empty")
 			os.Exit(1)
 		}
+		if env.TestPostgres18Port == "" {
+			log.Error("TEST_POSTGRES_18_PORT is empty")
+			os.Exit(1)
+		}
 
 		if env.TestMinioPort == "" {
 			log.Error("TEST_MINIO_PORT is empty")
@@ -161,6 +168,11 @@ func loadEnvVariables() {
 			log.Error("TEST_MINIO_CONSOLE_PORT is empty")
 			os.Exit(1)
 		}
+
+		if env.TestNASPort == "" {
+			log.Error("TEST_NAS_PORT is empty")
+			os.Exit(1)
+		}
 	}
 
 	log.Info("Environment variables loaded successfully!")

backend/internal/features/backups/backups/di.go

@@ -44,6 +44,7 @@ func SetupDependencies() {
 		SetDatabaseStorageChangeListener(backupService)
 
 	databases.GetDatabaseService().AddDbRemoveListener(backupService)
+	databases.GetDatabaseService().AddDbCopyListener(backups_config.GetBackupConfigService())
 }
 
 func GetBackupService() *BackupService {

backend/internal/features/backups/backups/service.go

@@ -242,7 +242,7 @@ func (s *BackupService) MakeBackup(databaseID uuid.UUID, isLastTry bool) {
 		)
 	}
 
-	if !isLastTry {
+	if backup.Status != BackupStatusCompleted && !isLastTry {
 		return
 	}
 

backend/internal/features/backups/backups/usecases/postgresql/create_backup_uc.go

@@ -60,8 +60,7 @@ func (uc *CreatePostgresqlBackupUsecase) Execute(
 	}
 
 	args := []string{
-		"-Fc",     // custom format with built-in compression
-		"-Z", "6", // balanced compression level (0-9, 6 is balanced)
+		"-Fc",           // custom format with built-in compression
 		"--no-password", // Use environment variable for password, prevent prompts
 		"-h", pg.Host,
 		"-p", strconv.Itoa(pg.Port),
@@ -70,6 +69,17 @@ func (uc *CreatePostgresqlBackupUsecase) Execute(
 		"--verbose", // Add verbose output to help with debugging
 	}
 
+	// Use zstd compression level 5 for PostgreSQL 15+ (better compression and speed)
+	// Fall back to gzip compression level 5 for older versions
+	if pg.Version == tools.PostgresqlVersion13 || pg.Version == tools.PostgresqlVersion14 ||
+		pg.Version == tools.PostgresqlVersion15 {
+		args = append(args, "-Z", "5")
+		uc.logger.Info("Using gzip compression level 5 (zstd not available)", "version", pg.Version)
+	} else {
+		args = append(args, "--compress=zstd:5")
+		uc.logger.Info("Using zstd compression level 5", "version", pg.Version)
+	}
+
 	return uc.streamToStorage(
 		backupID,
 		backupConfig,
@@ -100,7 +110,9 @@ func (uc *CreatePostgresqlBackupUsecase) streamToStorage(
 ) error {
 	uc.logger.Info("Streaming PostgreSQL backup to storage", "pgBin", pgBin, "args", args)
 
-	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Minute)
+	// if backup not fit into 23 hours, Postgresus
+	// seems not to work for such database size
+	ctx, cancel := context.WithTimeout(context.Background(), 23*time.Hour)
 	defer cancel()
 
 	// Monitor for shutdown and cancel context if needed
@@ -255,10 +267,10 @@ func (uc *CreatePostgresqlBackupUsecase) streamToStorage(
 		copyResultCh <- err
 	}()
 
-	// Wait for the dump and copy to finish
-	waitErr := cmd.Wait()
+	// Wait for the copy to finish first, then the dump process
 	copyErr := <-copyResultCh
 	bytesWritten := <-bytesWrittenCh
+	waitErr := cmd.Wait()
 
 	// Check for shutdown before finalizing
 	if config.IsShouldShutdown() {

backend/internal/features/backups/config/model.go

@@ -90,3 +90,18 @@ func (b *BackupConfig) Validate() error {
 
 	return nil
 }
+
+func (b *BackupConfig) Copy(newDatabaseID uuid.UUID) *BackupConfig {
+	return &BackupConfig{
+		DatabaseID:          newDatabaseID,
+		IsBackupsEnabled:    b.IsBackupsEnabled,
+		StorePeriod:         b.StorePeriod,
+		BackupIntervalID:    uuid.Nil,
+		BackupInterval:      b.BackupInterval.Copy(),
+		StorageID:           b.StorageID,
+		SendNotificationsOn: b.SendNotificationsOn,
+		IsRetryIfFailed:     b.IsRetryIfFailed,
+		MaxFailedTriesCount: b.MaxFailedTriesCount,
+		CpuCount:            b.CpuCount,
+	}
+}

backend/internal/features/backups/config/service.go

@@ -56,7 +56,8 @@ func (s *BackupConfigService) SaveBackupConfig(
 	if existingConfig != nil {
 		// If storage is changing, notify the listener
 		if s.dbStorageChangeListener != nil &&
-			!storageIDsEqual(existingConfig.StorageID, backupConfig.StorageID) {
+			backupConfig.Storage != nil &&
+			!storageIDsEqual(existingConfig.StorageID, &backupConfig.Storage.ID) {
 			if err := s.dbStorageChangeListener.OnBeforeBackupsStorageChange(
 				backupConfig.DatabaseID,
 			); err != nil {
@@ -129,6 +130,20 @@ func (s *BackupConfigService) GetBackupConfigsWithEnabledBackups() ([]*BackupCon
 	return s.backupConfigRepository.GetWithEnabledBackups()
 }
 
+func (s *BackupConfigService) OnDatabaseCopied(originalDatabaseID, newDatabaseID uuid.UUID) {
+	originalConfig, err := s.GetBackupConfigByDbId(originalDatabaseID)
+	if err != nil {
+		return
+	}
+
+	newConfig := originalConfig.Copy(newDatabaseID)
+
+	_, err = s.SaveBackupConfig(newConfig)
+	if err != nil {
+		return
+	}
+}
+
 func (s *BackupConfigService) initializeDefaultConfig(
 	databaseID uuid.UUID,
 ) error {

backend/internal/features/databases/controller.go

@@ -21,6 +21,7 @@ func (c *DatabaseController) RegisterRoutes(router *gin.RouterGroup) {
 	router.GET("/databases", c.GetDatabases)
 	router.POST("/databases/:id/test-connection", c.TestDatabaseConnection)
 	router.POST("/databases/test-connection-direct", c.TestDatabaseConnectionDirect)
+	router.POST("/databases/:id/copy", c.CopyDatabase)
 	router.GET("/databases/notifier/:id/is-using", c.IsNotifierUsing)
 
 }
@@ -325,3 +326,42 @@ func (c *DatabaseController) IsNotifierUsing(ctx *gin.Context) {
 
 	ctx.JSON(http.StatusOK, gin.H{"isUsing": isUsing})
 }
+
+// CopyDatabase
+// @Summary Copy a database
+// @Description Copy an existing database configuration
+// @Tags databases
+// @Produce json
+// @Param id path string true "Database ID"
+// @Success 201 {object} Database
+// @Failure 400
+// @Failure 401
+// @Failure 500
+// @Router /databases/{id}/copy [post]
+func (c *DatabaseController) CopyDatabase(ctx *gin.Context) {
+	id, err := uuid.Parse(ctx.Param("id"))
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": "invalid database ID"})
+		return
+	}
+
+	authorizationHeader := ctx.GetHeader("Authorization")
+	if authorizationHeader == "" {
+		ctx.JSON(http.StatusUnauthorized, gin.H{"error": "authorization header is required"})
+		return
+	}
+
+	user, err := c.userService.GetUserFromToken(authorizationHeader)
+	if err != nil {
+		ctx.JSON(http.StatusUnauthorized, gin.H{"error": "invalid token"})
+		return
+	}
+
+	copiedDatabase, err := c.databaseService.CopyDatabase(user, id)
+	if err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	ctx.JSON(http.StatusCreated, copiedDatabase)
+}

backend/internal/features/databases/databases/postgresql/model.go

@@ -7,6 +7,7 @@ import (
 	"log/slog"
 	"postgresus-backend/internal/util/tools"
 	"regexp"
+	"slices"
 	"time"
 
 	"github.com/google/uuid"
@@ -175,3 +176,101 @@ func buildConnectionStringForDB(p *PostgresqlDatabase, dbName string) string {
 		sslMode,
 	)
 }
+
+func (p *PostgresqlDatabase) InstallExtensions(extensions []tools.PostgresqlExtension) error {
+	if len(extensions) == 0 {
+		return nil
+	}
+
+	if p.Database == nil || *p.Database == "" {
+		return errors.New("database name is required for installing extensions")
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+
+	// Build connection string for the specific database
+	connStr := buildConnectionStringForDB(p, *p.Database)
+
+	// Connect to database
+	conn, err := pgx.Connect(ctx, connStr)
+	if err != nil {
+		return fmt.Errorf("failed to connect to database '%s': %w", *p.Database, err)
+	}
+	defer func() {
+		if closeErr := conn.Close(ctx); closeErr != nil {
+			fmt.Println("failed to close connection: %w", closeErr)
+		}
+	}()
+
+	// Check which extensions are already installed
+	installedExtensions, err := p.getInstalledExtensions(ctx, conn)
+	if err != nil {
+		return fmt.Errorf("failed to check installed extensions: %w", err)
+	}
+
+	// Install missing extensions
+	for _, extension := range extensions {
+		if contains(installedExtensions, string(extension)) {
+			continue // Extension already installed
+		}
+
+		if err := p.installExtension(ctx, conn, string(extension)); err != nil {
+			return fmt.Errorf("failed to install extension '%s': %w", extension, err)
+		}
+	}
+
+	return nil
+}
+
+// getInstalledExtensions queries the database for currently installed extensions
+func (p *PostgresqlDatabase) getInstalledExtensions(
+	ctx context.Context,
+	conn *pgx.Conn,
+) ([]string, error) {
+	query := "SELECT extname FROM pg_extension"
+
+	rows, err := conn.Query(ctx, query)
+	if err != nil {
+		return nil, fmt.Errorf("failed to query installed extensions: %w", err)
+	}
+	defer rows.Close()
+
+	var extensions []string
+	for rows.Next() {
+		var extname string
+
+		if err := rows.Scan(&extname); err != nil {
+			return nil, fmt.Errorf("failed to scan extension name: %w", err)
+		}
+
+		extensions = append(extensions, extname)
+	}
+
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("error iterating over extension rows: %w", err)
+	}
+
+	return extensions, nil
+}
+
+// installExtension installs a single PostgreSQL extension
+func (p *PostgresqlDatabase) installExtension(
+	ctx context.Context,
+	conn *pgx.Conn,
+	extensionName string,
+) error {
+	query := fmt.Sprintf("CREATE EXTENSION IF NOT EXISTS %s", extensionName)
+
+	_, err := conn.Exec(ctx, query)
+	if err != nil {
+		return fmt.Errorf("failed to execute CREATE EXTENSION: %w", err)
+	}
+
+	return nil
+}
+
+// contains checks if a string slice contains a specific string
+func contains(slice []string, item string) bool {
+	return slices.Contains(slice, item)
+}

backend/internal/features/databases/di.go

@@ -14,6 +14,7 @@ var databaseService = &DatabaseService{
 	logger.GetLogger(),
 	[]DatabaseCreationListener{},
 	[]DatabaseRemoveListener{},
+	[]DatabaseCopyListener{},
 }
 
 var databaseController = &DatabaseController{

backend/internal/features/databases/interfaces.go

@@ -21,3 +21,7 @@ type DatabaseCreationListener interface {
 type DatabaseRemoveListener interface {
 	OnBeforeDatabaseRemove(databaseID uuid.UUID) error
 }
+
+type DatabaseCopyListener interface {
+	OnDatabaseCopied(originalDatabaseID, newDatabaseID uuid.UUID)
+}

backend/internal/features/databases/model.go

@@ -35,6 +35,10 @@ func (d *Database) Validate() error {
 
 	switch d.Type {
 	case DatabaseTypePostgres:
+		if d.Postgresql == nil {
+			return errors.New("postgresql database is required")
+		}
+
 		return d.Postgresql.Validate()
 	default:
 		return errors.New("invalid database type: " + string(d.Type))

backend/internal/features/databases/repository.go

@@ -1,6 +1,7 @@
 package databases
 
 import (
+	"errors"
 	"postgresus-backend/internal/features/databases/databases/postgresql"
 	"postgresus-backend/internal/storage"
 
@@ -21,9 +22,12 @@ func (r *DatabaseRepository) Save(database *Database) (*Database, error) {
 	err := db.Transaction(func(tx *gorm.DB) error {
 		switch database.Type {
 		case DatabaseTypePostgres:
-			if database.Postgresql != nil {
-				database.Postgresql.DatabaseID = &database.ID
+			if database.Postgresql == nil {
+				return errors.New("postgresql configuration is required for PostgreSQL database")
 			}
+
+			// Ensure DatabaseID is always set and never nil
+			database.Postgresql.DatabaseID = &database.ID
 		}
 
 		if isNew {
@@ -43,17 +47,15 @@ func (r *DatabaseRepository) Save(database *Database) (*Database, error) {
 		// Save the specific database type
 		switch database.Type {
 		case DatabaseTypePostgres:
-			if database.Postgresql != nil {
-				database.Postgresql.DatabaseID = &database.ID
-				if database.Postgresql.ID == uuid.Nil {
-					database.Postgresql.ID = uuid.New()
-					if err := tx.Create(database.Postgresql).Error; err != nil {
-						return err
-					}
-				} else {
-					if err := tx.Save(database.Postgresql).Error; err != nil {
-						return err
-					}
+			database.Postgresql.DatabaseID = &database.ID
+			if database.Postgresql.ID == uuid.Nil {
+				database.Postgresql.ID = uuid.New()
+				if err := tx.Create(database.Postgresql).Error; err != nil {
+					return err
+				}
+			} else {
+				if err := tx.Save(database.Postgresql).Error; err != nil {
+					return err
 				}
 			}
 		}

backend/internal/features/databases/service.go

@@ -3,6 +3,7 @@ package databases
 import (
 	"errors"
 	"log/slog"
+	"postgresus-backend/internal/features/databases/databases/postgresql"
 	"postgresus-backend/internal/features/notifiers"
 	users_models "postgresus-backend/internal/features/users/models"
 	"time"
@@ -17,6 +18,7 @@ type DatabaseService struct {
 
 	dbCreationListener []DatabaseCreationListener
 	dbRemoveListener   []DatabaseRemoveListener
+	dbCopyListener     []DatabaseCopyListener
 }
 
 func (s *DatabaseService) AddDbCreationListener(
@@ -31,6 +33,12 @@ func (s *DatabaseService) AddDbRemoveListener(
 	s.dbRemoveListener = append(s.dbRemoveListener, dbRemoveListener)
 }
 
+func (s *DatabaseService) AddDbCopyListener(
+	dbCopyListener DatabaseCopyListener,
+) {
+	s.dbCopyListener = append(s.dbCopyListener, dbCopyListener)
+}
+
 func (s *DatabaseService) CreateDatabase(
 	user *users_models.User,
 	database *Database,
@@ -220,6 +228,67 @@ func (s *DatabaseService) SetLastBackupTime(databaseID uuid.UUID, backupTime tim
 	return nil
 }
 
+func (s *DatabaseService) CopyDatabase(
+	user *users_models.User,
+	databaseID uuid.UUID,
+) (*Database, error) {
+	existingDatabase, err := s.dbRepository.FindByID(databaseID)
+	if err != nil {
+		return nil, err
+	}
+
+	if existingDatabase.UserID != user.ID {
+		return nil, errors.New("you have not access to this database")
+	}
+
+	newDatabase := &Database{
+		ID:                     uuid.Nil,
+		UserID:                 user.ID,
+		Name:                   existingDatabase.Name + " (Copy)",
+		Type:                   existingDatabase.Type,
+		Notifiers:              existingDatabase.Notifiers,
+		LastBackupTime:         nil,
+		LastBackupErrorMessage: nil,
+		HealthStatus:           existingDatabase.HealthStatus,
+	}
+
+	switch existingDatabase.Type {
+	case DatabaseTypePostgres:
+		if existingDatabase.Postgresql != nil {
+			newDatabase.Postgresql = &postgresql.PostgresqlDatabase{
+				ID:         uuid.Nil,
+				DatabaseID: nil,
+				Version:    existingDatabase.Postgresql.Version,
+				Host:       existingDatabase.Postgresql.Host,
+				Port:       existingDatabase.Postgresql.Port,
+				Username:   existingDatabase.Postgresql.Username,
+				Password:   existingDatabase.Postgresql.Password,
+				Database:   existingDatabase.Postgresql.Database,
+				IsHttps:    existingDatabase.Postgresql.IsHttps,
+			}
+		}
+	}
+
+	if err := newDatabase.Validate(); err != nil {
+		return nil, err
+	}
+
+	copiedDatabase, err := s.dbRepository.Save(newDatabase)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, listener := range s.dbCreationListener {
+		listener.OnDatabaseCreated(copiedDatabase.ID)
+	}
+
+	for _, listener := range s.dbCopyListener {
+		listener.OnDatabaseCopied(databaseID, copiedDatabase.ID)
+	}
+
+	return copiedDatabase, nil
+}
+
 func (s *DatabaseService) SetHealthStatus(
 	databaseID uuid.UUID,
 	healthStatus *HealthStatus,

backend/internal/features/healthcheck/attempt/background_service.go

@@ -13,7 +13,7 @@ type HealthcheckAttemptBackgroundService struct {
 	logger                   *slog.Logger
 }
 
-func (s *HealthcheckAttemptBackgroundService) RunBackgroundTasks() {
+func (s *HealthcheckAttemptBackgroundService) Run() {
 	// first healthcheck immediately
 	s.checkDatabases()
 

backend/internal/features/healthcheck/attempt/check_pg_health_uc.go

@@ -224,7 +224,7 @@ func (uc *CheckPgHealthUseCase) sendDbStatusNotification(
 	messageBody := ""
 
 	if newHealthStatus == databases.HealthStatusAvailable {
-		messageTitle = fmt.Sprintf("✅ [%s] DB is back online", database.Name)
+		messageTitle = fmt.Sprintf("✅ [%s] DB is online", database.Name)
 		messageBody = fmt.Sprintf("✅ [%s] DB is back online", database.Name)
 	} else {
 		messageTitle = fmt.Sprintf("❌ [%s] DB is unavailable", database.Name)

backend/internal/features/healthcheck/attempt/check_pg_health_uc_test.go

@@ -303,7 +303,7 @@ func Test_CheckPgHealthUseCase(t *testing.T) {
 			t,
 			"SendNotification",
 			mock.Anything,
-			fmt.Sprintf("✅ [%s] DB is back online", database.Name),
+			fmt.Sprintf("✅ [%s] DB is online", database.Name),
 			fmt.Sprintf("✅ [%s] DB is back online", database.Name),
 		)
 	})

backend/internal/features/intervals/model.go

@@ -64,6 +64,16 @@ func (i *Interval) ShouldTriggerBackup(now time.Time, lastBackupTime *time.Time)
 	}
 }
 
+func (i *Interval) Copy() *Interval {
+	return &Interval{
+		ID:         uuid.Nil,
+		Interval:   i.Interval,
+		TimeOfDay:  i.TimeOfDay,
+		Weekday:    i.Weekday,
+		DayOfMonth: i.DayOfMonth,
+	}
+}
+
 // daily trigger: honour the TimeOfDay slot and catch up the previous one
 func (i *Interval) shouldTriggerDaily(now, lastBackup time.Time) bool {
 	if i.TimeOfDay == nil {

backend/internal/features/notifiers/enums.go

@@ -8,4 +8,5 @@ const (
 	NotifierTypeWebhook  NotifierType = "WEBHOOK"
 	NotifierTypeSlack    NotifierType = "SLACK"
 	NotifierTypeDiscord  NotifierType = "DISCORD"
+	NotifierTypeTeams    NotifierType = "TEAMS"
 )

backend/internal/features/notifiers/model.go

@@ -6,6 +6,7 @@ import (
 	discord_notifier "postgresus-backend/internal/features/notifiers/models/discord"
 	"postgresus-backend/internal/features/notifiers/models/email_notifier"
 	slack_notifier "postgresus-backend/internal/features/notifiers/models/slack"
+	teams_notifier "postgresus-backend/internal/features/notifiers/models/teams"
 	telegram_notifier "postgresus-backend/internal/features/notifiers/models/telegram"
 	webhook_notifier "postgresus-backend/internal/features/notifiers/models/webhook"
 
@@ -20,11 +21,12 @@ type Notifier struct {
 	LastSendError *string      `json:"lastSendError" gorm:"column:last_send_error;type:text"`
 
 	// specific notifier
-	TelegramNotifier *telegram_notifier.TelegramNotifier `json:"telegramNotifier" gorm:"foreignKey:NotifierID"`
-	EmailNotifier    *email_notifier.EmailNotifier       `json:"emailNotifier"    gorm:"foreignKey:NotifierID"`
-	WebhookNotifier  *webhook_notifier.WebhookNotifier   `json:"webhookNotifier"  gorm:"foreignKey:NotifierID"`
-	SlackNotifier    *slack_notifier.SlackNotifier       `json:"slackNotifier"    gorm:"foreignKey:NotifierID"`
-	DiscordNotifier  *discord_notifier.DiscordNotifier   `json:"discordNotifier"  gorm:"foreignKey:NotifierID"`
+	TelegramNotifier *telegram_notifier.TelegramNotifier `json:"telegramNotifier"        gorm:"foreignKey:NotifierID"`
+	EmailNotifier    *email_notifier.EmailNotifier       `json:"emailNotifier"           gorm:"foreignKey:NotifierID"`
+	WebhookNotifier  *webhook_notifier.WebhookNotifier   `json:"webhookNotifier"         gorm:"foreignKey:NotifierID"`
+	SlackNotifier    *slack_notifier.SlackNotifier       `json:"slackNotifier"           gorm:"foreignKey:NotifierID"`
+	DiscordNotifier  *discord_notifier.DiscordNotifier   `json:"discordNotifier"         gorm:"foreignKey:NotifierID"`
+	TeamsNotifier    *teams_notifier.TeamsNotifier       `json:"teamsNotifier,omitempty" gorm:"foreignKey:NotifierID;constraint:OnDelete:CASCADE"`
 }
 
 func (n *Notifier) TableName() string {
@@ -64,6 +66,8 @@ func (n *Notifier) getSpecificNotifier() NotificationSender {
 		return n.SlackNotifier
 	case NotifierTypeDiscord:
 		return n.DiscordNotifier
+	case NotifierTypeTeams:
+		return n.TeamsNotifier
 	default:
 		panic("unknown notifier type: " + string(n.NotifierType))
 	}

backend/internal/features/notifiers/models/teams/model.go

@@ -0,0 +1,96 @@
+package teams_notifier
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"log/slog"
+	"net/http"
+	"net/url"
+
+	"github.com/google/uuid"
+)
+
+type TeamsNotifier struct {
+	NotifierID uuid.UUID `gorm:"type:uuid;primaryKey;column:notifier_id"      json:"notifierId"`
+	WebhookURL string    `gorm:"type:text;not null;column:power_automate_url" json:"powerAutomateUrl"`
+}
+
+func (TeamsNotifier) TableName() string {
+	return "teams_notifiers"
+}
+
+func (n *TeamsNotifier) Validate() error {
+	if n.WebhookURL == "" {
+		return errors.New("webhook_url is required")
+	}
+	u, err := url.Parse(n.WebhookURL)
+	if err != nil || (u.Scheme != "http" && u.Scheme != "https") {
+		return errors.New("invalid webhook_url")
+	}
+	return nil
+}
+
+type cardAttachment struct {
+	ContentType string      `json:"contentType"`
+	Content     interface{} `json:"content"`
+}
+
+type payload struct {
+	Title       string           `json:"title"`
+	Text        string           `json:"text"`
+	Attachments []cardAttachment `json:"attachments,omitempty"`
+}
+
+func (n *TeamsNotifier) Send(logger *slog.Logger, heading, message string) error {
+	if err := n.Validate(); err != nil {
+		return err
+	}
+
+	card := map[string]any{
+		"type":    "AdaptiveCard",
+		"version": "1.4",
+		"body": []any{
+			map[string]any{
+				"type":   "TextBlock",
+				"size":   "Medium",
+				"weight": "Bolder",
+				"text":   heading,
+			},
+			map[string]any{"type": "TextBlock", "wrap": true, "text": message},
+		},
+	}
+
+	p := payload{
+		Title: heading,
+		Text:  message,
+		Attachments: []cardAttachment{
+			{ContentType: "application/vnd.microsoft.card.adaptive", Content: card},
+		},
+	}
+
+	body, _ := json.Marshal(p)
+	req, err := http.NewRequest(http.MethodPost, n.WebhookURL, bytes.NewReader(body))
+	if err != nil {
+		return err
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return err
+	}
+
+	defer func() {
+		if closeErr := resp.Body.Close(); closeErr != nil {
+			logger.Error("failed to close response body", "error", closeErr)
+		}
+	}()
+
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return fmt.Errorf("teams webhook returned status %d", resp.StatusCode)
+	}
+
+	return nil
+}

backend/internal/features/notifiers/models/telegram/model.go

@@ -7,6 +7,7 @@ import (
 	"log/slog"
 	"net/http"
 	"net/url"
+	"strconv"
 	"strings"
 
 	"github.com/google/uuid"
@@ -16,6 +17,7 @@ type TelegramNotifier struct {
 	NotifierID   uuid.UUID `json:"notifierId"   gorm:"primaryKey;column:notifier_id"`
 	BotToken     string    `json:"botToken"     gorm:"not null;column:bot_token"`
 	TargetChatID string    `json:"targetChatId" gorm:"not null;column:target_chat_id"`
+	ThreadID     *int64    `json:"threadId"     gorm:"column:thread_id"`
 }
 
 func (t *TelegramNotifier) TableName() string {
@@ -47,6 +49,10 @@ func (t *TelegramNotifier) Send(logger *slog.Logger, heading string, message str
 	data.Set("text", fullMessage)
 	data.Set("parse_mode", "HTML")
 
+	if t.ThreadID != nil && *t.ThreadID != 0 {
+		data.Set("message_thread_id", strconv.FormatInt(*t.ThreadID, 10))
+	}
+
 	req, err := http.NewRequest("POST", apiURL, strings.NewReader(data.Encode()))
 	if err != nil {
 		return fmt.Errorf("failed to create request: %w", err)

backend/internal/features/notifiers/repository.go

@@ -13,6 +13,7 @@ func (r *NotifierRepository) Save(notifier *Notifier) (*Notifier, error) {
 	db := storage.GetDb()
 
 	err := db.Transaction(func(tx *gorm.DB) error {
+
 		switch notifier.NotifierType {
 		case NotifierTypeTelegram:
 			if notifier.TelegramNotifier != nil {
@@ -34,30 +35,36 @@ func (r *NotifierRepository) Save(notifier *Notifier) (*Notifier, error) {
 			if notifier.DiscordNotifier != nil {
 				notifier.DiscordNotifier.NotifierID = notifier.ID
 			}
+		case NotifierTypeTeams:
+			if notifier.TeamsNotifier != nil {
+				notifier.TeamsNotifier.NotifierID = notifier.ID
+			}
 		}
 
 		if notifier.ID == uuid.Nil {
-			if err := tx.Create(notifier).
+			if err := tx.
 				Omit(
 					"TelegramNotifier",
 					"EmailNotifier",
 					"WebhookNotifier",
 					"SlackNotifier",
 					"DiscordNotifier",
+					"TeamsNotifier",
 				).
-				Error; err != nil {
+				Create(notifier).Error; err != nil {
 				return err
 			}
 		} else {
-			if err := tx.Save(notifier).
+			if err := tx.
 				Omit(
 					"TelegramNotifier",
 					"EmailNotifier",
 					"WebhookNotifier",
 					"SlackNotifier",
 					"DiscordNotifier",
+					"TeamsNotifier",
 				).
-				Error; err != nil {
+				Save(notifier).Error; err != nil {
 				return err
 			}
 		}
@@ -65,39 +72,46 @@ func (r *NotifierRepository) Save(notifier *Notifier) (*Notifier, error) {
 		switch notifier.NotifierType {
 		case NotifierTypeTelegram:
 			if notifier.TelegramNotifier != nil {
-				notifier.TelegramNotifier.NotifierID = notifier.ID // Ensure ID is set
+				notifier.TelegramNotifier.NotifierID = notifier.ID
 				if err := tx.Save(notifier.TelegramNotifier).Error; err != nil {
 					return err
 				}
 			}
 		case NotifierTypeEmail:
 			if notifier.EmailNotifier != nil {
-				notifier.EmailNotifier.NotifierID = notifier.ID // Ensure ID is set
+				notifier.EmailNotifier.NotifierID = notifier.ID
 				if err := tx.Save(notifier.EmailNotifier).Error; err != nil {
 					return err
 				}
 			}
 		case NotifierTypeWebhook:
 			if notifier.WebhookNotifier != nil {
-				notifier.WebhookNotifier.NotifierID = notifier.ID // Ensure ID is set
+				notifier.WebhookNotifier.NotifierID = notifier.ID
 				if err := tx.Save(notifier.WebhookNotifier).Error; err != nil {
 					return err
 				}
 			}
 		case NotifierTypeSlack:
 			if notifier.SlackNotifier != nil {
-				notifier.SlackNotifier.NotifierID = notifier.ID // Ensure ID is set
+				notifier.SlackNotifier.NotifierID = notifier.ID
 				if err := tx.Save(notifier.SlackNotifier).Error; err != nil {
 					return err
 				}
 			}
 		case NotifierTypeDiscord:
 			if notifier.DiscordNotifier != nil {
-				notifier.DiscordNotifier.NotifierID = notifier.ID // Ensure ID is set
+				notifier.DiscordNotifier.NotifierID = notifier.ID
 				if err := tx.Save(notifier.DiscordNotifier).Error; err != nil {
 					return err
 				}
 			}
+		case NotifierTypeTeams:
+			if notifier.TeamsNotifier != nil {
+				notifier.TeamsNotifier.NotifierID = notifier.ID
+				if err := tx.Save(notifier.TeamsNotifier).Error; err != nil {
+					return err
+				}
+			}
 		}
 
 		return nil
@@ -120,6 +134,7 @@ func (r *NotifierRepository) FindByID(id uuid.UUID) (*Notifier, error) {
 		Preload("WebhookNotifier").
 		Preload("SlackNotifier").
 		Preload("DiscordNotifier").
+		Preload("TeamsNotifier").
 		Where("id = ?", id).
 		First(&notifier).Error; err != nil {
 		return nil, err
@@ -138,6 +153,7 @@ func (r *NotifierRepository) FindByUserID(userID uuid.UUID) ([]*Notifier, error)
 		Preload("WebhookNotifier").
 		Preload("SlackNotifier").
 		Preload("DiscordNotifier").
+		Preload("TeamsNotifier").
 		Where("user_id = ?", userID).
 		Order("name ASC").
 		Find(&notifiers).Error; err != nil {
@@ -149,7 +165,7 @@ func (r *NotifierRepository) FindByUserID(userID uuid.UUID) ([]*Notifier, error)
 
 func (r *NotifierRepository) Delete(notifier *Notifier) error {
 	return storage.GetDb().Transaction(func(tx *gorm.DB) error {
-		// Delete specific notifier based on type
+
 		switch notifier.NotifierType {
 		case NotifierTypeTelegram:
 			if notifier.TelegramNotifier != nil {
@@ -181,9 +197,14 @@ func (r *NotifierRepository) Delete(notifier *Notifier) error {
 					return err
 				}
 			}
+		case NotifierTypeTeams:
+			if notifier.TeamsNotifier != nil {
+				if err := tx.Delete(notifier.TeamsNotifier).Error; err != nil {
+					return err
+				}
+			}
 		}
 
-		// Delete the main notifier
 		return tx.Delete(notifier).Error
 	})
 }

backend/internal/features/restores/usecases/postgresql/restore_backup_uc.go

@@ -20,6 +20,7 @@ import (
 	pgtypes "postgresus-backend/internal/features/databases/databases/postgresql"
 	"postgresus-backend/internal/features/restores/models"
 	"postgresus-backend/internal/features/storages"
+	files_utils "postgresus-backend/internal/util/files"
 	"postgresus-backend/internal/util/tools"
 
 	"github.com/google/uuid"
@@ -163,7 +164,7 @@ func (uc *RestorePostgresqlBackupUsecase) restoreFromStorage(
 	// Add the temporary backup file as the last argument to pg_restore
 	args = append(args, tempBackupFile)
 
-	return uc.executePgRestore(ctx, pgBin, args, pgpassFile, pgConfig)
+	return uc.executePgRestore(ctx, pgBin, args, pgpassFile, pgConfig, backup)
 }
 
 // downloadBackupToTempFile downloads backup data from storage to a temporary file
@@ -172,6 +173,13 @@ func (uc *RestorePostgresqlBackupUsecase) downloadBackupToTempFile(
 	backup *backups.Backup,
 	storage *storages.Storage,
 ) (string, func(), error) {
+	err := files_utils.EnsureDirectories([]string{
+		config.GetEnv().TempFolder,
+	})
+	if err != nil {
+		return "", nil, fmt.Errorf("failed to ensure directories: %w", err)
+	}
+
 	// Create temporary directory for backup data
 	tempDir, err := os.MkdirTemp(config.GetEnv().TempFolder, "restore_"+uuid.New().String())
 	if err != nil {
@@ -222,11 +230,8 @@ func (uc *RestorePostgresqlBackupUsecase) downloadBackupToTempFile(
 		return "", nil, fmt.Errorf("failed to write backup to temporary file: %w", err)
 	}
 
-	// Close the temp file to ensure all data is written
-	if err := tempFile.Close(); err != nil {
-		cleanupFunc()
-		return "", nil, fmt.Errorf("failed to close temporary backup file: %w", err)
-	}
+	// Close the temp file to ensure all data is written - this is handled by defer
+	// Removing explicit close to avoid double-close error
 
 	uc.logger.Info("Backup file written to temporary location", "tempFile", tempBackupFile)
 	return tempBackupFile, cleanupFunc, nil
@@ -239,6 +244,7 @@ func (uc *RestorePostgresqlBackupUsecase) executePgRestore(
 	args []string,
 	pgpassFile string,
 	pgConfig *pgtypes.PostgresqlDatabase,
+	backup *backups.Backup,
 ) error {
 	cmd := exec.CommandContext(ctx, pgBin, args...)
 	uc.logger.Info("Executing PostgreSQL restore command", "command", cmd.String())
@@ -287,7 +293,7 @@ func (uc *RestorePostgresqlBackupUsecase) executePgRestore(
 			return fmt.Errorf("restore cancelled due to shutdown")
 		}
 
-		return uc.handlePgRestoreError(waitErr, stderrOutput, pgBin, args)
+		return uc.handlePgRestoreError(waitErr, stderrOutput, pgBin, args, backup, pgConfig)
 	}
 
 	return nil
@@ -339,6 +345,8 @@ func (uc *RestorePostgresqlBackupUsecase) handlePgRestoreError(
 	stderrOutput []byte,
 	pgBin string,
 	args []string,
+	backup *backups.Backup,
+	pgConfig *pgtypes.PostgresqlDatabase,
 ) error {
 	// Enhanced error handling for PostgreSQL connection and restore issues
 	stderrStr := string(stderrOutput)
@@ -407,8 +415,20 @@ func (uc *RestorePostgresqlBackupUsecase) handlePgRestoreError(
 					stderrStr,
 				)
 			} else if containsIgnoreCase(stderrStr, "database") && containsIgnoreCase(stderrStr, "does not exist") {
+				backupDbName := "unknown"
+				if backup.Database != nil && backup.Database.Postgresql != nil && backup.Database.Postgresql.Database != nil {
+					backupDbName = *backup.Database.Postgresql.Database
+				}
+
+				targetDbName := "unknown"
+				if pgConfig.Database != nil {
+					targetDbName = *pgConfig.Database
+				}
+
 				errorMsg = fmt.Sprintf(
-					"Target database does not exist. Create the database before restoring. stderr: %s",
+					"Target database does not exist (backup db %s, not found %s). Create the database before restoring. stderr: %s",
+					backupDbName,
+					targetDbName,
 					stderrStr,
 				)
 			}

backend/internal/features/storages/enums.go

@@ -6,4 +6,5 @@ const (
 	StorageTypeLocal       StorageType = "LOCAL"
 	StorageTypeS3          StorageType = "S3"
 	StorageTypeGoogleDrive StorageType = "GOOGLE_DRIVE"
+	StorageTypeNAS         StorageType = "NAS"
 )

backend/internal/features/storages/model.go

@@ -6,6 +6,7 @@ import (
 	"log/slog"
 	google_drive_storage "postgresus-backend/internal/features/storages/models/google_drive"
 	local_storage "postgresus-backend/internal/features/storages/models/local"
+	nas_storage "postgresus-backend/internal/features/storages/models/nas"
 	s3_storage "postgresus-backend/internal/features/storages/models/s3"
 
 	"github.com/google/uuid"
@@ -22,6 +23,7 @@ type Storage struct {
 	LocalStorage       *local_storage.LocalStorage              `json:"localStorage"       gorm:"foreignKey:StorageID"`
 	S3Storage          *s3_storage.S3Storage                    `json:"s3Storage"          gorm:"foreignKey:StorageID"`
 	GoogleDriveStorage *google_drive_storage.GoogleDriveStorage `json:"googleDriveStorage" gorm:"foreignKey:StorageID"`
+	NASStorage         *nas_storage.NASStorage                  `json:"nasStorage"         gorm:"foreignKey:StorageID"`
 }
 
 func (s *Storage) SaveFile(logger *slog.Logger, fileID uuid.UUID, file io.Reader) error {
@@ -69,6 +71,8 @@ func (s *Storage) getSpecificStorage() StorageFileSaver {
 		return s.S3Storage
 	case StorageTypeGoogleDrive:
 		return s.GoogleDriveStorage
+	case StorageTypeNAS:
+		return s.NASStorage
 	default:
 		panic("invalid storage type: " + string(s.Type))
 	}

backend/internal/features/storages/model_test.go

@@ -10,8 +10,10 @@ import (
 	"postgresus-backend/internal/config"
 	google_drive_storage "postgresus-backend/internal/features/storages/models/google_drive"
 	local_storage "postgresus-backend/internal/features/storages/models/local"
+	nas_storage "postgresus-backend/internal/features/storages/models/nas"
 	s3_storage "postgresus-backend/internal/features/storages/models/s3"
 	"postgresus-backend/internal/util/logger"
+	"strconv"
 	"testing"
 	"time"
 
@@ -44,6 +46,14 @@ func Test_Storage_BasicOperations(t *testing.T) {
 	require.NoError(t, err, "Failed to setup test file")
 	defer os.Remove(testFilePath)
 
+	// Setup NAS port
+	nasPort := 445
+	if portStr := config.GetEnv().TestNASPort; portStr != "" {
+		if port, err := strconv.Atoi(portStr); err == nil {
+			nasPort = port
+		}
+	}
+
 	// Run tests
 	testCases := []struct {
 		name    string
@@ -65,14 +75,39 @@ func Test_Storage_BasicOperations(t *testing.T) {
 			},
 		},
 		{
+			name: "NASStorage",
+			storage: &nas_storage.NASStorage{
+				StorageID: uuid.New(),
+				Host:      "localhost",
+				Port:      nasPort,
+				Share:     "backups",
+				Username:  "testuser",
+				Password:  "testpassword",
+				UseSSL:    false,
+				Domain:    "",
+				Path:      "test-files",
+			},
+		},
+	}
+
+	// Add Google Drive storage test only if environment variables are available
+	env := config.GetEnv()
+	if env.TestGoogleDriveClientID != "" && env.TestGoogleDriveClientSecret != "" &&
+		env.TestGoogleDriveTokenJSON != "" {
+		testCases = append(testCases, struct {
+			name    string
+			storage StorageFileSaver
+		}{
 			name: "GoogleDriveStorage",
 			storage: &google_drive_storage.GoogleDriveStorage{
 				StorageID:    uuid.New(),
-				ClientID:     config.GetEnv().TestGoogleDriveClientID,
-				ClientSecret: config.GetEnv().TestGoogleDriveClientSecret,
-				TokenJSON:    config.GetEnv().TestGoogleDriveTokenJSON,
+				ClientID:     env.TestGoogleDriveClientID,
+				ClientSecret: env.TestGoogleDriveClientSecret,
+				TokenJSON:    env.TestGoogleDriveTokenJSON,
 			},
-		},
+		})
+	} else {
+		t.Log("Skipping Google Drive storage test: missing environment variables")
 	}
 
 	for _, tc := range testCases {
@@ -197,8 +232,6 @@ func setupS3Container(ctx context.Context) (*S3Container, error) {
 
 func validateEnvVariables(t *testing.T) {
 	env := config.GetEnv()
-	assert.NotEmpty(t, env.TestGoogleDriveClientID, "TEST_GOOGLE_DRIVE_CLIENT_ID is empty")
-	assert.NotEmpty(t, env.TestGoogleDriveClientSecret, "TEST_GOOGLE_DRIVE_CLIENT_SECRET is empty")
-	assert.NotEmpty(t, env.TestGoogleDriveTokenJSON, "TEST_GOOGLE_DRIVE_TOKEN_JSON is empty")
 	assert.NotEmpty(t, env.TestMinioPort, "TEST_MINIO_PORT is empty")
+	assert.NotEmpty(t, env.TestNASPort, "TEST_NAS_PORT is empty")
 }

backend/internal/features/storages/models/local/model.go

@@ -7,6 +7,7 @@ import (
 	"os"
 	"path/filepath"
 	"postgresus-backend/internal/config"
+	files_utils "postgresus-backend/internal/util/files"
 
 	"github.com/google/uuid"
 )
@@ -25,9 +26,11 @@ func (l *LocalStorage) TableName() string {
 func (l *LocalStorage) SaveFile(logger *slog.Logger, fileID uuid.UUID, file io.Reader) error {
 	logger.Info("Starting to save file to local storage", "fileId", fileID.String())
 
-	if err := l.ensureDirectories(); err != nil {
-		logger.Error("Failed to ensure directories", "fileId", fileID.String(), "error", err)
-		return err
+	err := files_utils.EnsureDirectories([]string{
+		config.GetEnv().TempFolder,
+	})
+	if err != nil {
+		return fmt.Errorf("failed to ensure directories: %w", err)
 	}
 
 	tempFilePath := filepath.Join(config.GetEnv().TempFolder, fileID.String())
@@ -62,8 +65,8 @@ func (l *LocalStorage) SaveFile(logger *slog.Logger, fileID uuid.UUID, file io.R
 		return fmt.Errorf("failed to sync temp file: %w", err)
 	}
 
-	err = tempFile.Close()
-	if err != nil {
+	// Close the temp file explicitly before moving it (required on Windows)
+	if err = tempFile.Close(); err != nil {
 		logger.Error("Failed to close temp file", "fileId", fileID.String(), "error", err)
 		return fmt.Errorf("failed to close temp file: %w", err)
 	}
@@ -134,14 +137,10 @@ func (l *LocalStorage) DeleteFile(fileID uuid.UUID) error {
 }
 
 func (l *LocalStorage) Validate() error {
-	return l.ensureDirectories()
+	return nil
 }
 
 func (l *LocalStorage) TestConnection() error {
-	if err := l.ensureDirectories(); err != nil {
-		return err
-	}
-
 	testFile := filepath.Join(config.GetEnv().TempFolder, "test_connection")
 	f, err := os.Create(testFile)
 	if err != nil {
@@ -157,19 +156,3 @@ func (l *LocalStorage) TestConnection() error {
 
 	return nil
 }
-
-func (l *LocalStorage) ensureDirectories() error {
-	// Standard permissions for directories: owner
-	// can read/write/execute, others can read/execute
-	const directoryPermissions = 0755
-
-	if err := os.MkdirAll(config.GetEnv().DataFolder, directoryPermissions); err != nil {
-		return fmt.Errorf("failed to create backups directory: %w", err)
-	}
-
-	if err := os.MkdirAll(config.GetEnv().TempFolder, directoryPermissions); err != nil {
-		return fmt.Errorf("failed to create temp directory: %w", err)
-	}
-
-	return nil
-}

backend/internal/features/storages/models/nas/model.go

@@ -0,0 +1,401 @@
+package nas_storage
+
+import (
+	"crypto/tls"
+	"errors"
+	"fmt"
+	"io"
+	"log/slog"
+	"net"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/hirochachacha/go-smb2"
+)
+
+type NASStorage struct {
+	StorageID uuid.UUID `json:"storageId" gorm:"primaryKey;type:uuid;column:storage_id"`
+	Host      string    `json:"host"      gorm:"not null;type:text;column:host"`
+	Port      int       `json:"port"      gorm:"not null;default:445;column:port"`
+	Share     string    `json:"share"     gorm:"not null;type:text;column:share"`
+	Username  string    `json:"username"  gorm:"not null;type:text;column:username"`
+	Password  string    `json:"password"  gorm:"not null;type:text;column:password"`
+	UseSSL    bool      `json:"useSsl"    gorm:"not null;default:false;column:use_ssl"`
+	Domain    string    `json:"domain"    gorm:"type:text;column:domain"`
+	Path      string    `json:"path"      gorm:"type:text;column:path"`
+}
+
+func (n *NASStorage) TableName() string {
+	return "nas_storages"
+}
+
+func (n *NASStorage) SaveFile(logger *slog.Logger, fileID uuid.UUID, file io.Reader) error {
+	logger.Info("Starting to save file to NAS storage", "fileId", fileID.String(), "host", n.Host)
+
+	session, err := n.createSession()
+	if err != nil {
+		logger.Error("Failed to create NAS session", "fileId", fileID.String(), "error", err)
+		return fmt.Errorf("failed to create NAS session: %w", err)
+	}
+	defer func() {
+		if logoffErr := session.Logoff(); logoffErr != nil {
+			logger.Error(
+				"Failed to logoff NAS session",
+				"fileId",
+				fileID.String(),
+				"error",
+				logoffErr,
+			)
+		}
+	}()
+
+	fs, err := session.Mount(n.Share)
+	if err != nil {
+		logger.Error(
+			"Failed to mount NAS share",
+			"fileId",
+			fileID.String(),
+			"share",
+			n.Share,
+			"error",
+			err,
+		)
+		return fmt.Errorf("failed to mount share '%s': %w", n.Share, err)
+	}
+	defer func() {
+		if umountErr := fs.Umount(); umountErr != nil {
+			logger.Error(
+				"Failed to unmount NAS share",
+				"fileId",
+				fileID.String(),
+				"error",
+				umountErr,
+			)
+		}
+	}()
+
+	// Ensure the directory exists
+	if n.Path != "" {
+		if err := n.ensureDirectory(fs, n.Path); err != nil {
+			logger.Error(
+				"Failed to ensure directory",
+				"fileId",
+				fileID.String(),
+				"path",
+				n.Path,
+				"error",
+				err,
+			)
+			return fmt.Errorf("failed to ensure directory: %w", err)
+		}
+	}
+
+	filePath := n.getFilePath(fileID.String())
+	logger.Debug("Creating file on NAS", "fileId", fileID.String(), "filePath", filePath)
+
+	nasFile, err := fs.Create(filePath)
+	if err != nil {
+		logger.Error(
+			"Failed to create file on NAS",
+			"fileId",
+			fileID.String(),
+			"filePath",
+			filePath,
+			"error",
+			err,
+		)
+		return fmt.Errorf("failed to create file on NAS: %w", err)
+	}
+	defer func() {
+		if closeErr := nasFile.Close(); closeErr != nil {
+			logger.Error("Failed to close NAS file", "fileId", fileID.String(), "error", closeErr)
+		}
+	}()
+
+	logger.Debug("Copying file data to NAS", "fileId", fileID.String())
+	_, err = io.Copy(nasFile, file)
+	if err != nil {
+		logger.Error("Failed to write file to NAS", "fileId", fileID.String(), "error", err)
+		return fmt.Errorf("failed to write file to NAS: %w", err)
+	}
+
+	logger.Info(
+		"Successfully saved file to NAS storage",
+		"fileId",
+		fileID.String(),
+		"filePath",
+		filePath,
+	)
+	return nil
+}
+
+func (n *NASStorage) GetFile(fileID uuid.UUID) (io.ReadCloser, error) {
+	session, err := n.createSession()
+	if err != nil {
+		return nil, fmt.Errorf("failed to create NAS session: %w", err)
+	}
+
+	fs, err := session.Mount(n.Share)
+	if err != nil {
+		_ = session.Logoff()
+		return nil, fmt.Errorf("failed to mount share '%s': %w", n.Share, err)
+	}
+
+	filePath := n.getFilePath(fileID.String())
+
+	// Check if file exists
+	_, err = fs.Stat(filePath)
+	if err != nil {
+		_ = fs.Umount()
+		_ = session.Logoff()
+		return nil, fmt.Errorf("file not found: %s", fileID.String())
+	}
+
+	nasFile, err := fs.Open(filePath)
+	if err != nil {
+		_ = fs.Umount()
+		_ = session.Logoff()
+		return nil, fmt.Errorf("failed to open file from NAS: %w", err)
+	}
+
+	// Return a wrapped reader that cleans up resources when closed
+	return &nasFileReader{
+		file:    nasFile,
+		fs:      fs,
+		session: session,
+	}, nil
+}
+
+func (n *NASStorage) DeleteFile(fileID uuid.UUID) error {
+	session, err := n.createSession()
+	if err != nil {
+		return fmt.Errorf("failed to create NAS session: %w", err)
+	}
+	defer func() {
+		_ = session.Logoff()
+	}()
+
+	fs, err := session.Mount(n.Share)
+	if err != nil {
+		return fmt.Errorf("failed to mount share '%s': %w", n.Share, err)
+	}
+	defer func() {
+		_ = fs.Umount()
+	}()
+
+	filePath := n.getFilePath(fileID.String())
+
+	// Check if file exists before trying to delete
+	_, err = fs.Stat(filePath)
+	if err != nil {
+		// File doesn't exist, consider it already deleted
+		return nil
+	}
+
+	err = fs.Remove(filePath)
+	if err != nil {
+		return fmt.Errorf("failed to delete file from NAS: %w", err)
+	}
+
+	return nil
+}
+
+func (n *NASStorage) Validate() error {
+	if n.Host == "" {
+		return errors.New("NAS host is required")
+	}
+	if n.Share == "" {
+		return errors.New("NAS share is required")
+	}
+	if n.Username == "" {
+		return errors.New("NAS username is required")
+	}
+	if n.Password == "" {
+		return errors.New("NAS password is required")
+	}
+	if n.Port <= 0 || n.Port > 65535 {
+		return errors.New("NAS port must be between 1 and 65535")
+	}
+
+	// Test the configuration by creating a session
+	return n.TestConnection()
+}
+
+func (n *NASStorage) TestConnection() error {
+	session, err := n.createSession()
+	if err != nil {
+		return fmt.Errorf("failed to connect to NAS: %w", err)
+	}
+	defer func() {
+		_ = session.Logoff()
+	}()
+
+	// Try to mount the share to verify access
+	fs, err := session.Mount(n.Share)
+	if err != nil {
+		return fmt.Errorf("failed to access share '%s': %w", n.Share, err)
+	}
+	defer func() {
+		_ = fs.Umount()
+	}()
+
+	// If path is specified, check if it exists or can be created
+	if n.Path != "" {
+		if err := n.ensureDirectory(fs, n.Path); err != nil {
+			return fmt.Errorf("failed to access or create path '%s': %w", n.Path, err)
+		}
+	}
+
+	return nil
+}
+
+func (n *NASStorage) createSession() (*smb2.Session, error) {
+	// Create connection with timeout
+	conn, err := n.createConnection()
+	if err != nil {
+		return nil, err
+	}
+
+	// Create SMB2 dialer
+	d := &smb2.Dialer{
+		Initiator: &smb2.NTLMInitiator{
+			User:     n.Username,
+			Password: n.Password,
+			Domain:   n.Domain,
+		},
+	}
+
+	// Create session
+	session, err := d.Dial(conn)
+	if err != nil {
+		_ = conn.Close()
+		return nil, fmt.Errorf("failed to create SMB session: %w", err)
+	}
+
+	return session, nil
+}
+
+func (n *NASStorage) createConnection() (net.Conn, error) {
+	address := net.JoinHostPort(n.Host, fmt.Sprintf("%d", n.Port))
+
+	// Create connection with timeout
+	dialer := &net.Dialer{
+		Timeout: 10 * time.Second,
+	}
+
+	if n.UseSSL {
+		// Use TLS connection
+		tlsConfig := &tls.Config{
+			ServerName:         n.Host,
+			InsecureSkipVerify: false, // Change to true if you want to skip cert verification
+		}
+
+		conn, err := tls.DialWithDialer(dialer, "tcp", address, tlsConfig)
+		if err != nil {
+			return nil, fmt.Errorf("failed to create SSL connection to %s: %w", address, err)
+		}
+		return conn, nil
+	} else {
+		// Use regular TCP connection
+		conn, err := dialer.Dial("tcp", address)
+		if err != nil {
+			return nil, fmt.Errorf("failed to create connection to %s: %w", address, err)
+		}
+		return conn, nil
+	}
+}
+
+func (n *NASStorage) ensureDirectory(fs *smb2.Share, path string) error {
+	// Clean and normalize the path
+	path = filepath.Clean(path)
+	path = strings.ReplaceAll(path, "\\", "/")
+
+	// Check if directory already exists
+	_, err := fs.Stat(path)
+	if err == nil {
+		return nil // Directory exists
+	}
+
+	// Try to create the directory (including parent directories)
+	parts := strings.Split(path, "/")
+	currentPath := ""
+
+	for _, part := range parts {
+		if part == "" || part == "." {
+			continue
+		}
+
+		if currentPath == "" {
+			currentPath = part
+		} else {
+			currentPath = currentPath + "/" + part
+		}
+
+		// Check if this part of the path exists
+		_, err := fs.Stat(currentPath)
+		if err != nil {
+			// Directory doesn't exist, try to create it
+			err = fs.Mkdir(currentPath, 0755)
+			if err != nil {
+				return fmt.Errorf("failed to create directory '%s': %w", currentPath, err)
+			}
+		}
+	}
+
+	return nil
+}
+
+func (n *NASStorage) getFilePath(filename string) string {
+	if n.Path == "" {
+		return filename
+	}
+
+	// Clean path and use forward slashes for SMB
+	cleanPath := filepath.Clean(n.Path)
+	cleanPath = strings.ReplaceAll(cleanPath, "\\", "/")
+
+	return cleanPath + "/" + filename
+}
+
+// nasFileReader wraps the NAS file and handles cleanup of resources
+type nasFileReader struct {
+	file    *smb2.File
+	fs      *smb2.Share
+	session *smb2.Session
+}
+
+func (r *nasFileReader) Read(p []byte) (n int, err error) {
+	return r.file.Read(p)
+}
+
+func (r *nasFileReader) Close() error {
+	// Close resources in reverse order
+	var errors []error
+
+	if r.file != nil {
+		if err := r.file.Close(); err != nil {
+			errors = append(errors, fmt.Errorf("failed to close file: %w", err))
+		}
+	}
+
+	if r.fs != nil {
+		if err := r.fs.Umount(); err != nil {
+			errors = append(errors, fmt.Errorf("failed to unmount share: %w", err))
+		}
+	}
+
+	if r.session != nil {
+		if err := r.session.Logoff(); err != nil {
+			errors = append(errors, fmt.Errorf("failed to logoff session: %w", err))
+		}
+	}
+
+	if len(errors) > 0 {
+		// Return the first error, but log others if needed
+		return errors[0]
+	}
+
+	return nil
+}

backend/internal/features/storages/models/s3/model.go

@@ -1,6 +1,7 @@
 package s3_storage
 
 import (
+	"bytes"
 	"context"
 	"errors"
 	"fmt"
@@ -129,7 +130,7 @@ func (s *S3Storage) TestConnection() error {
 		return err
 	}
 
-	// Create a context with 5 second timeout
+	// Create a context with 10 second timeout
 	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 	defer cancel()
 
@@ -147,6 +148,35 @@ func (s *S3Storage) TestConnection() error {
 		return fmt.Errorf("bucket '%s' does not exist", s.S3Bucket)
 	}
 
+	// Test write and delete permissions by uploading and removing a small test file
+	testFileID := uuid.New().String() + "-test"
+	testData := []byte("test connection")
+	testReader := bytes.NewReader(testData)
+
+	// Upload test file
+	_, err = client.PutObject(
+		ctx,
+		s.S3Bucket,
+		testFileID,
+		testReader,
+		int64(len(testData)),
+		minio.PutObjectOptions{},
+	)
+	if err != nil {
+		return fmt.Errorf("failed to upload test file to S3: %w", err)
+	}
+
+	// Delete test file
+	err = client.RemoveObject(
+		ctx,
+		s.S3Bucket,
+		testFileID,
+		minio.RemoveObjectOptions{},
+	)
+	if err != nil {
+		return fmt.Errorf("failed to delete test file from S3: %w", err)
+	}
+
 	return nil
 }
 

backend/internal/features/storages/repository.go

@@ -26,17 +26,21 @@ func (r *StorageRepository) Save(storage *Storage) (*Storage, error) {
 			if storage.GoogleDriveStorage != nil {
 				storage.GoogleDriveStorage.StorageID = storage.ID
 			}
+		case StorageTypeNAS:
+			if storage.NASStorage != nil {
+				storage.NASStorage.StorageID = storage.ID
+			}
 		}
 
 		if storage.ID == uuid.Nil {
 			if err := tx.Create(storage).
-				Omit("LocalStorage", "S3Storage", "GoogleDriveStorage").
+				Omit("LocalStorage", "S3Storage", "GoogleDriveStorage", "NASStorage").
 				Error; err != nil {
 				return err
 			}
 		} else {
 			if err := tx.Save(storage).
-				Omit("LocalStorage", "S3Storage", "GoogleDriveStorage").
+				Omit("LocalStorage", "S3Storage", "GoogleDriveStorage", "NASStorage").
 				Error; err != nil {
 				return err
 			}
@@ -64,6 +68,13 @@ func (r *StorageRepository) Save(storage *Storage) (*Storage, error) {
 					return err
 				}
 			}
+		case StorageTypeNAS:
+			if storage.NASStorage != nil {
+				storage.NASStorage.StorageID = storage.ID // Ensure ID is set
+				if err := tx.Save(storage.NASStorage).Error; err != nil {
+					return err
+				}
+			}
 		}
 
 		return nil
@@ -84,6 +95,7 @@ func (r *StorageRepository) FindByID(id uuid.UUID) (*Storage, error) {
 		Preload("LocalStorage").
 		Preload("S3Storage").
 		Preload("GoogleDriveStorage").
+		Preload("NASStorage").
 		Where("id = ?", id).
 		First(&s).Error; err != nil {
 		return nil, err
@@ -100,6 +112,7 @@ func (r *StorageRepository) FindByUserID(userID uuid.UUID) ([]*Storage, error) {
 		Preload("LocalStorage").
 		Preload("S3Storage").
 		Preload("GoogleDriveStorage").
+		Preload("NASStorage").
 		Where("user_id = ?", userID).
 		Order("name ASC").
 		Find(&storages).Error; err != nil {
@@ -131,6 +144,12 @@ func (r *StorageRepository) Delete(s *Storage) error {
 					return err
 				}
 			}
+		case StorageTypeNAS:
+			if s.NASStorage != nil {
+				if err := tx.Delete(s.NASStorage).Error; err != nil {
+					return err
+				}
+			}
 		}
 
 		// Delete the main storage

backend/internal/features/tests/postgresql_backup_restore_test.go

@@ -73,6 +73,7 @@ func Test_BackupAndRestorePostgresql_RestoreIsSuccesful(t *testing.T) {
 		{"PostgreSQL 15", "15", env.TestPostgres15Port},
 		{"PostgreSQL 16", "16", env.TestPostgres16Port},
 		{"PostgreSQL 17", "17", env.TestPostgres17Port},
+		{"PostgreSQL 18", "18", env.TestPostgres18Port},
 	}
 
 	for _, tc := range cases {
@@ -222,10 +223,14 @@ func verifyDataIntegrity(t *testing.T, originalDB *sqlx.DB, restoredDB *sqlx.DB)
 	assert.NoError(t, err)
 
 	assert.Equal(t, len(originalData), len(restoredData), "Should have same number of rows")
-	for i := range originalData {
-		assert.Equal(t, originalData[i].ID, restoredData[i].ID, "ID should match")
-		assert.Equal(t, originalData[i].Name, restoredData[i].Name, "Name should match")
-		assert.Equal(t, originalData[i].Value, restoredData[i].Value, "Value should match")
+
+	// Only compare data if both slices have elements (to avoid panic)
+	if len(originalData) > 0 && len(restoredData) > 0 {
+		for i := range originalData {
+			assert.Equal(t, originalData[i].ID, restoredData[i].ID, "ID should match")
+			assert.Equal(t, originalData[i].Name, restoredData[i].Name, "Name should match")
+			assert.Equal(t, originalData[i].Value, restoredData[i].Value, "Value should match")
+		}
 	}
 }
 

backend/internal/features/users/controller.go

@@ -4,10 +4,12 @@ import (
 	"net/http"
 
 	"github.com/gin-gonic/gin"
+	"golang.org/x/time/rate"
 )
 
 type UserController struct {
-	userService *UserService
+	userService   *UserService
+	signinLimiter *rate.Limiter
 }
 
 func (c *UserController) RegisterRoutes(router *gin.RouterGroup) {
@@ -51,8 +53,18 @@ func (c *UserController) SignUp(ctx *gin.Context) {
 // @Param request body SignInRequest true "User signin data"
 // @Success 200 {object} SignInResponse
 // @Failure 400
+// @Failure 429 {object} map[string]string "Rate limit exceeded"
 // @Router /users/signin [post]
 func (c *UserController) SignIn(ctx *gin.Context) {
+	// We use rate limiter to prevent brute force attacks
+	if !c.signinLimiter.Allow() {
+		ctx.JSON(
+			http.StatusTooManyRequests,
+			gin.H{"error": "Rate limit exceeded. Please try again later."},
+		)
+		return
+	}
+
 	var request SignInRequest
 	if err := ctx.ShouldBindJSON(&request); err != nil {
 		ctx.JSON(http.StatusBadRequest, gin.H{"error": "Invalid request format"})

backend/internal/features/users/di.go

@@ -2,6 +2,8 @@ package users
 
 import (
 	user_repositories "postgresus-backend/internal/features/users/repositories"
+
+	"golang.org/x/time/rate"
 )
 
 var secretKeyRepository = &user_repositories.SecretKeyRepository{}
@@ -12,6 +14,7 @@ var userService = &UserService{
 }
 var userController = &UserController{
 	userService,
+	rate.NewLimiter(rate.Limit(3), 3), // 3 RPS with burst of 3
 }
 
 func GetUserService() *UserService {

backend/internal/util/files/cleaner.go

@@ -1,7 +1,27 @@
 package files_utils
 
-import "os"
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+)
 
 func CleanFolder(folder string) error {
-	return os.RemoveAll(folder)
+	if _, err := os.Stat(folder); os.IsNotExist(err) {
+		return nil
+	}
+
+	entries, err := os.ReadDir(folder)
+	if err != nil {
+		return fmt.Errorf("failed to read directory %s: %w", folder, err)
+	}
+
+	for _, entry := range entries {
+		itemPath := filepath.Join(folder, entry.Name())
+		if err := os.RemoveAll(itemPath); err != nil {
+			return fmt.Errorf("failed to remove %s: %w", itemPath, err)
+		}
+	}
+
+	return nil
 }

backend/internal/util/files/creator.go

@@ -0,0 +1,22 @@
+package files_utils
+
+import (
+	"fmt"
+	"os"
+)
+
+func EnsureDirectories(directories []string) error {
+	const directoryPermissions = 0755
+
+	for _, directory := range directories {
+		if _, err := os.Stat(directory); os.IsNotExist(err) {
+			if err := os.MkdirAll(directory, directoryPermissions); err != nil {
+				return fmt.Errorf("failed to create directory %s: %w", directory, err)
+			}
+		} else if err != nil {
+			return fmt.Errorf("failed to check directory %s: %w", directory, err)
+		}
+	}
+
+	return nil
+}

backend/internal/util/tools/enums.go

@@ -5,6 +5,13 @@ import (
 	"strconv"
 )
 
+type PostgresqlExtension string
+
+const (
+	// needed for queries monitoring
+	PostgresqlExtensionPgStatMonitor PostgresqlExtension = "pg_stat_statements"
+)
+
 type PostgresqlVersion string
 
 const (
@@ -13,6 +20,7 @@ const (
 	PostgresqlVersion15 PostgresqlVersion = "15"
 	PostgresqlVersion16 PostgresqlVersion = "16"
 	PostgresqlVersion17 PostgresqlVersion = "17"
+	PostgresqlVersion18 PostgresqlVersion = "18"
 )
 
 type PostgresqlExecutable string
@@ -34,6 +42,8 @@ func GetPostgresqlVersionEnum(version string) PostgresqlVersion {
 		return PostgresqlVersion16
 	case "17":
 		return PostgresqlVersion17
+	case "18":
+		return PostgresqlVersion18
 	default:
 		panic(fmt.Sprintf("invalid postgresql version: %s", version))
 	}

backend/internal/util/tools/postgresql.go

@@ -46,6 +46,7 @@ func VerifyPostgresesInstallation(
 		PostgresqlVersion15,
 		PostgresqlVersion16,
 		PostgresqlVersion17,
+		PostgresqlVersion18,
 	}
 
 	requiredCommands := []PostgresqlExecutable{

backend/migrations/20250723135644_add_nas_storages.sql

@@ -0,0 +1,30 @@
+-- +goose Up
+-- +goose StatementBegin
+
+-- Create NAS storages table
+CREATE TABLE nas_storages (
+    storage_id  UUID PRIMARY KEY,
+    host        TEXT NOT NULL,
+    port        INTEGER NOT NULL DEFAULT 445,
+    share       TEXT NOT NULL,
+    username    TEXT NOT NULL,
+    password    TEXT NOT NULL,
+    use_ssl     BOOLEAN NOT NULL DEFAULT FALSE,
+    domain      TEXT,
+    path        TEXT
+);
+
+ALTER TABLE nas_storages
+    ADD CONSTRAINT fk_nas_storages_storage
+    FOREIGN KEY (storage_id)
+    REFERENCES storages (id)
+    ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED;
+
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+
+DROP TABLE IF EXISTS nas_storages;
+
+-- +goose StatementEnd 

backend/migrations/20250809062256_add_telegram_thread_id.sql

@@ -0,0 +1,15 @@
+-- +goose Up
+-- +goose StatementBegin
+
+ALTER TABLE telegram_notifiers 
+    ADD COLUMN thread_id BIGINT;
+
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+
+ALTER TABLE telegram_notifiers 
+    DROP COLUMN IF EXISTS thread_id;
+
+-- +goose StatementEnd

backend/migrations/20250906152330_add_ms_teams_notifier.sql

@@ -0,0 +1,20 @@
+-- +goose Up
+-- +goose StatementBegin
+
+CREATE TABLE teams_notifiers (
+     notifier_id        UUID PRIMARY KEY,
+     power_automate_url TEXT NOT NULL
+);
+
+ALTER TABLE teams_notifiers
+    ADD CONSTRAINT fk_teams_notifiers_notifier
+    FOREIGN KEY (notifier_id)
+    REFERENCES notifiers (id)
+    ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED;
+
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+DROP TABLE IF EXISTS teams_notifiers;
+-- +goose StatementEnd

backend/migrations/20250912092352_add_monitoring_metrics.sql

@@ -0,0 +1,60 @@
+-- +goose Up
+-- +goose StatementBegin
+
+-- Create postgres_monitoring_settings table
+CREATE TABLE postgres_monitoring_settings (
+    database_id                             UUID PRIMARY KEY,
+    is_db_resources_monitoring_enabled      BOOLEAN NOT NULL DEFAULT FALSE,
+    monitoring_interval_seconds             BIGINT NOT NULL DEFAULT 60,
+    installed_extensions_raw                TEXT
+);
+
+-- Add foreign key constraint for postgres_monitoring_settings
+ALTER TABLE postgres_monitoring_settings
+    ADD CONSTRAINT fk_postgres_monitoring_settings_database_id
+    FOREIGN KEY (database_id)
+    REFERENCES databases (id)
+    ON DELETE CASCADE;
+
+-- Create postgres_monitoring_metrics table
+CREATE TABLE postgres_monitoring_metrics (
+    id          UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    database_id UUID NOT NULL,
+    metric      TEXT NOT NULL,
+    value_type  TEXT NOT NULL,
+    value       DOUBLE PRECISION NOT NULL,
+    created_at  TIMESTAMPTZ NOT NULL
+);
+
+-- Add foreign key constraint for postgres_monitoring_metrics
+ALTER TABLE postgres_monitoring_metrics
+    ADD CONSTRAINT fk_postgres_monitoring_metrics_database_id
+    FOREIGN KEY (database_id)
+    REFERENCES databases (id)
+    ON DELETE CASCADE;
+
+-- Add indexes for performance
+CREATE INDEX idx_postgres_monitoring_metrics_database_id
+    ON postgres_monitoring_metrics (database_id);
+
+CREATE INDEX idx_postgres_monitoring_metrics_created_at
+    ON postgres_monitoring_metrics (created_at);
+
+CREATE INDEX idx_postgres_monitoring_metrics_database_metric_created_at
+    ON postgres_monitoring_metrics (database_id, metric, created_at);
+
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+
+-- Drop indexes first
+DROP INDEX IF EXISTS idx_postgres_monitoring_metrics_database_metric_created_at;
+DROP INDEX IF EXISTS idx_postgres_monitoring_metrics_created_at;
+DROP INDEX IF EXISTS idx_postgres_monitoring_metrics_database_id;
+
+-- Drop tables in reverse order
+DROP TABLE IF EXISTS postgres_monitoring_metrics;
+DROP TABLE IF EXISTS postgres_monitoring_settings;
+
+-- +goose StatementEnd

backend/temp/nas/.deleted/test-files/8c6e587a-0eae-44c1-b82c-e5a8db2b3642

@@ -0,0 +1 @@
+This is test data for storage testing

backend/temp/nas/test-files/86d3f727-2a60-4a86-af86-31657237d21c

@@ -0,0 +1 @@
+This is test data for storage testing

backend/tools/download_linux.sh

@@ -2,7 +2,10 @@
 
 set -e  # Exit on any error
 
-echo "Installing PostgreSQL client tools versions 13-17 for Linux (Debian/Ubuntu)..."
+# Ensure non-interactive mode for apt
+export DEBIAN_FRONTEND=noninteractive
+
+echo "Installing PostgreSQL client tools versions 13-18 for Linux (Debian/Ubuntu)..."
 echo
 
 # Check if running on supported system
@@ -30,55 +33,54 @@ echo
 
 # Add PostgreSQL official APT repository
 echo "Adding PostgreSQL official APT repository..."
-$SUDO apt-get update -qq
-$SUDO apt-get install -y wget ca-certificates
+$SUDO apt-get update -qq -y
+$SUDO apt-get install -y -qq wget ca-certificates
 
 # Add GPG key
-wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | $SUDO apt-key add -
+wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | $SUDO apt-key add - 2>/dev/null
 
 # Add repository
-echo "deb http://apt.postgresql.org/pub/repos/apt/ $(lsb_release -cs)-pgdg main" | $SUDO tee /etc/apt/sources.list.d/pgdg.list
+echo "deb http://apt.postgresql.org/pub/repos/apt/ $(lsb_release -cs)-pgdg main" | $SUDO tee /etc/apt/sources.list.d/pgdg.list >/dev/null
 
 # Update package list
 echo "Updating package list..."
-$SUDO apt-get update -qq
+$SUDO apt-get update -qq -y
 
 # Install client tools for each version
-versions="13 14 15 16 17"
+versions="13 14 15 16 17 18"
 
 for version in $versions; do
     echo "Installing PostgreSQL $version client tools..."
     
     # Install client tools only
-    $SUDO apt-get install -y postgresql-client-$version
+    $SUDO apt-get install -y -qq postgresql-client-$version
     
     # Create version-specific directory and symlinks
     version_dir="$POSTGRES_DIR/postgresql-$version"
     mkdir -p "$version_dir/bin"
     
-    # Create symlinks to the installed binaries
-    if [ -f "/usr/bin/pg_dump" ]; then
-        # If multiple versions, binaries are usually named with version suffix
-        if [ -f "/usr/bin/pg_dump-$version" ]; then
-            ln -sf "/usr/bin/pg_dump-$version" "$version_dir/bin/pg_dump"
-            ln -sf "/usr/bin/pg_dumpall-$version" "$version_dir/bin/pg_dumpall"
-            ln -sf "/usr/bin/psql-$version" "$version_dir/bin/psql"
-            ln -sf "/usr/bin/pg_restore-$version" "$version_dir/bin/pg_restore"
-            ln -sf "/usr/bin/createdb-$version" "$version_dir/bin/createdb"
-            ln -sf "/usr/bin/dropdb-$version" "$version_dir/bin/dropdb"
-        else
-            # Fallback to non-versioned names (latest version)
-            ln -sf "/usr/bin/pg_dump" "$version_dir/bin/pg_dump"
-            ln -sf "/usr/bin/pg_dumpall" "$version_dir/bin/pg_dumpall"
-            ln -sf "/usr/bin/psql" "$version_dir/bin/psql"
-            ln -sf "/usr/bin/pg_restore" "$version_dir/bin/pg_restore"
-            ln -sf "/usr/bin/createdb" "$version_dir/bin/createdb"
-            ln -sf "/usr/bin/dropdb" "$version_dir/bin/dropdb"
-        fi
+    # On Debian/Ubuntu, PostgreSQL binaries are located in /usr/lib/postgresql/{version}/bin/
+    pg_bin_dir="/usr/lib/postgresql/$version/bin"
+    
+    if [ -d "$pg_bin_dir" ] && [ -f "$pg_bin_dir/pg_dump" ]; then
+        # Create symlinks to the version-specific binaries
+        ln -sf "$pg_bin_dir/pg_dump" "$version_dir/bin/pg_dump"
+        ln -sf "$pg_bin_dir/pg_dumpall" "$version_dir/bin/pg_dumpall"
+        ln -sf "$pg_bin_dir/psql" "$version_dir/bin/psql"
+        ln -sf "$pg_bin_dir/pg_restore" "$version_dir/bin/pg_restore"
+        ln -sf "$pg_bin_dir/createdb" "$version_dir/bin/createdb"
+        ln -sf "$pg_bin_dir/dropdb" "$version_dir/bin/dropdb"
         
         echo "PostgreSQL $version client tools installed successfully"
     else
-        echo "Warning: PostgreSQL $version client tools may not have installed correctly"
+        echo "Error: PostgreSQL $version binaries not found in expected location: $pg_bin_dir"
+        echo "Available PostgreSQL directories:"
+        ls -la /usr/lib/postgresql/ 2>/dev/null || echo "No PostgreSQL directories found in /usr/lib/postgresql/"
+        if [ -d "$pg_bin_dir" ]; then
+            echo "Contents of $pg_bin_dir:"
+            ls -la "$pg_bin_dir" 2>/dev/null || echo "Directory exists but cannot list contents"
+        fi
+        exit 1
     fi
     echo
 done
@@ -93,6 +95,9 @@ for version in $versions; do
     version_dir="$POSTGRES_DIR/postgresql-$version"
     if [ -f "$version_dir/bin/pg_dump" ]; then
         echo "  postgresql-$version: $version_dir/bin/"
+        # Verify the correct version
+        version_output=$("$version_dir/bin/pg_dump" --version 2>/dev/null | grep -o "pg_dump (PostgreSQL) [0-9]\+\.[0-9]\+")
+        echo "    Version check: $version_output"
     fi
 done
 

backend/tools/download_macos.sh

@@ -2,7 +2,7 @@
 
 set -e  # Exit on any error
 
-echo "Installing PostgreSQL client tools versions 13-17 for MacOS..."
+echo "Installing PostgreSQL client tools versions 13-18 for MacOS..."
 echo
 
 # Check if Homebrew is installed
@@ -36,6 +36,7 @@ declare -A PG_URLS=(
     ["15"]="https://ftp.postgresql.org/pub/source/v15.8/postgresql-15.8.tar.gz"
     ["16"]="https://ftp.postgresql.org/pub/source/v16.4/postgresql-16.4.tar.gz"
     ["17"]="https://ftp.postgresql.org/pub/source/v17.0/postgresql-17.0.tar.gz"
+    ["18"]="https://ftp.postgresql.org/pub/source/v18.0/postgresql-18.0.tar.gz"
 )
 
 # Create temporary build directory
@@ -106,7 +107,7 @@ build_postgresql_client() {
 }
 
 # Build each version
-versions="13 14 15 16 17"
+versions="13 14 15 16 17 18"
 
 for version in $versions; do
     url=${PG_URLS[$version]}

backend/tools/download_windows.bat

@@ -1,7 +1,7 @@
 @echo off
 setlocal enabledelayedexpansion
 
-echo Downloading and installing PostgreSQL versions 13-17 for Windows...
+echo Downloading and installing PostgreSQL versions 13-18 for Windows...
 echo.
 
 :: Create downloads and postgresql directories if they don't exist
@@ -22,9 +22,10 @@ set "PG14_URL=%BASE_URL%/postgresql-14.13-1-windows-x64.exe"
 set "PG15_URL=%BASE_URL%/postgresql-15.8-1-windows-x64.exe"
 set "PG16_URL=%BASE_URL%/postgresql-16.4-1-windows-x64.exe"
 set "PG17_URL=%BASE_URL%/postgresql-17.0-1-windows-x64.exe"
+set "PG18_URL=%BASE_URL%/postgresql-18.0-1-windows-x64.exe"
 
 :: Array of versions
-set "versions=13 14 15 16 17"
+set "versions=13 14 15 16 17 18"
 
 :: Download and install each version
 for %%v in (%versions%) do (

backend/tools/readme.md

@@ -1,6 +1,6 @@
-This directory is needed only for development.
+This directory is needed only for development and CI\CD.
 
-We have to download and install all the PostgreSQL versions from 13 to 17 locally.
+We have to download and install all the PostgreSQL versions from 13 to 18 locally.
 This is needed so we can call pg_dump, pg_dumpall, etc. on each version of the PostgreSQL database.
 
 You do not need to install PostgreSQL fully with all the components.
@@ -13,6 +13,7 @@ We have to install the following:
 - PostgreSQL 15
 - PostgreSQL 16
 - PostgreSQL 17
+- PostgreSQL 18
 
 ## Installation
 
@@ -76,6 +77,7 @@ For example:
 - `./tools/postgresql/postgresql-15/bin/pg_dump`
 - `./tools/postgresql/postgresql-16/bin/pg_dump`
 - `./tools/postgresql/postgresql-17/bin/pg_dump`
+- `./tools/postgresql/postgresql-18/bin/pg_dump`
 
 ## Usage
 

contribute/README.md

@@ -37,9 +37,12 @@ Example:
 Before any commit, make sure:
 
 1. You created critical tests for your changes
-2. `golangci-lint fmt` and `golangci-lint run` are passing
+2. `make lint` is passing (for backend) and `npm run lint` is passing (for frontend)
 3. All tests are passing
 4. Project is building successfully
+5. All your commits should be squashed into one commit with proper message (or to meaningful parts)
+6. Code do really refactored and production ready
+7. You have one single PR per one feature (at least, if features not connected)
 
 ### Automated Versioning
 
@@ -68,8 +71,15 @@ If you need to add some explanation, do it in appropriate place in the code. Or
 
 Before taking anything more than a couple of lines of code, please write Rostislav via Telegram (@rostislav_dugin) and confirm priority. It is possible that we already have something in the works, it is not needed or it's not project priority.
 
+Nearsest features:
+- add API keys and API actions
+
 Backups flow:
 
+- check Neon backups flow
+- check AWS S3 support
+- when testing connection with S3 - verify files can be really uploaded
+- do not remove old backups on backups disable
 - add FTP
 - add Dropbox
 - add OneDrive
@@ -82,43 +92,16 @@ Backups flow:
 Notifications flow:
 
 - add Mattermost
-- add MS Teams
 
 Extra:
 
-- add tests running on each PR (in progress by Rostislav Dugin)
-- add prettier labels to GitHub README
-- create pretty website like rybbit.io with demo
 - add HTTPS for Postgresus
 - add simple SQL queries via UI
-- add brute force protection on auth (via local RPS limiter)
 - add support of Kubernetes Helm
+- create pretty website like rybbit.io with demo
 
 Monitoring flow:
 
-- add system metrics (CPU, RAM, disk, IO)
 - add queries stats (slowest, most frequent, etc. via pg_stat_statements)
-- add alerting for slow queries (listen for slow query and if they reach >100ms - send message)
-- add alerting for high resource usage (listen for high resource usage and if they reach >90% - send message)
 - add DB size distribution chart (tables, indexes, etc.)
-- add performance test for DB (to compare DBs on different clouds and VPS)
-- add DB metrics (pg_stat_activity, pg_locks, pg_stat_database)
 - add chart of connections (from IPs, apps names, etc.)
-- add chart of transactions (TPS)
-- deadlocks chart
-- chart of connection attempts (to see crash loops)
-- add chart of IDLE transactions VS executing transactions
-- show queries that take the most IO time (suboptimal indexes)
-- show chart by top IO / CPU queries usage (see page 90 of the PostgreSQL monitoring book)
-
-```
-exec_time | IO   | CPU | query
-105 hrs   | 73%  | 27% | SELECT * FROM users;
-```
-
-- chart of read / update / delete / insert queries
-- chart with deadlocks, conflicts, rollbacks (see page 115 of the PostgreSQL monitoring book)
-- stats of buffer usage
-- status of IO (DB, indexes, sequences)
-- % of cache hit
-- replication stats

contribute/how-to-add-notifier.md

@@ -0,0 +1,45 @@
+# How to add new notifier to Postgresus (Discord, Slack, Telegram, Email, Webhook, etc.)
+
+## Backend part
+
+1. Create new model in `backend/internal/features/notifiers/models/{notifier_name}/` folder. Implement `NotificationSender` interface from parent folder.
+   - The model should implement `Send(logger *slog.Logger, heading string, message string) error` and `Validate() error` methods
+   - Use UUID primary key as `NotifierID` that references the main notifiers table
+
+2. Add new notifier type to `backend/internal/features/notifiers/enums.go` in the `NotifierType` constants.
+
+3. Update the main `Notifier` model in `backend/internal/features/notifiers/model.go`:
+   - Add new notifier field with GORM foreign key relation
+   - Update `getSpecificNotifier()` method to handle the new type
+   - Update `Send()` method to route to the new notifier
+
+4. If you need to add some .env variables to test, add them in `backend/internal/config/config.go` (so we can use it in tests)
+
+5. If you need some Docker container to test, add it to `backend/docker-compose.yml.example`. For sensitive data - keep it blank.
+
+6. If you need some sensitive envs to test in pipeline, message @rostislav_dugin so I can add it to GitHub Actions. For example, API keys or credentials.
+
+7. Create new migration in `backend/migrations` folder:
+   - Create table with `notifier_id` as UUID primary key
+   - Add foreign key constraint to `notifiers` table with CASCADE DELETE
+   - Look at existing notifier migrations for reference
+
+8. Make sure that all tests are passing.
+
+## Frontend part
+
+If you are able to develop only backend - it's fine, message @rostislav_dugin so I can complete UI part.
+
+1. Add models and validator to `frontend/src/entity/notifiers/models/{notifier_name}/` folder and update `index.ts` file to include new model exports.
+
+2. Upload an SVG icon to `public/icons/notifiers/`, update `src/entity/notifiers/models/getNotifierLogoFromType.ts` to return new icon path, update `src/entity/notifiers/models/NotifierType.ts` to include new type, and update `src/entity/notifiers/models/getNotifierNameFromType.ts` to return new name.
+
+3. Add UI components to manage your notifier:
+   - `src/features/notifiers/ui/edit/notifiers/Edit{NotifierName}Component.tsx` (for editing)
+   - `src/features/notifiers/ui/show/notifier/Show{NotifierName}Component.tsx` (for display)
+
+4. Update main components to handle the new notifier type:
+   - `EditNotifierComponent.tsx` - add import, validation function, and component rendering
+   - `ShowNotifierComponent.tsx` - add import and component rendering
+
+5. Make sure everything is working as expected.

contribute/how-to-add-storage.md

@@ -0,0 +1,51 @@
+# How to add new storage to Postgresus (S3, FTP, Google Drive, NAS, etc.)
+
+## Backend part
+
+1. Create new model in `backend/internal/features/storages/models/{storage_name}/` folder. Implement `StorageFileSaver` interface from parent folder.
+   - The model should implement `SaveFile(logger *slog.Logger, fileID uuid.UUID, file io.Reader) error`, `GetFile(fileID uuid.UUID) (io.ReadCloser, error)`, `DeleteFile(fileID uuid.UUID) error`, `Validate() error`, and `TestConnection() error` methods
+   - Use UUID primary key as `StorageID` that references the main storages table
+   - Add `TableName() string` method to return the proper table name
+
+2. Add new storage type to `backend/internal/features/storages/enums.go` in the `StorageType` constants.
+
+3. Update the main `Storage` model in `backend/internal/features/storages/model.go`:
+   - Add new storage field with GORM foreign key relation
+   - Update `getSpecificStorage()` method to handle the new type
+   - Update `SaveFile()`, `GetFile()`, and `DeleteFile()` methods to route to the new storage
+   - Update `Validate()` method to include new storage validation
+
+4. If you need to add some .env variables to test, add them in `backend/internal/config/config.go` (so we can use it in tests)
+
+5. If you need some Docker container to test, add it to `backend/docker-compose.yml.example`. For sensitive data - keep it blank.
+
+6. If you need some sensitive envs to test in pipeline, message @rostislav_dugin so I can add it to GitHub Actions. For example, Google Drive envs or FTP credentials.
+
+7. Create new migration in `backend/migrations` folder:
+   - Create table with `storage_id` as UUID primary key
+   - Add foreign key constraint to `storages` table with CASCADE DELETE
+   - Look at existing storage migrations for reference
+
+8. Update tests in `backend/internal/features/storages/model_test.go` to test new storage
+
+9. Make sure that all tests are passing.
+
+## Frontend part
+
+If you are able to develop only backend - it's fine, message @rostislav_dugin so I can complete UI part.
+
+1. Add models and api to `frontend/src/entity/storages/models/` folder and update `index.ts` file to include new model exports.
+   - Create TypeScript interface for your storage model
+   - Add validation function if needed
+
+2. Upload an SVG icon to `public/icons/storages/`, update `src/entity/storages/models/getStorageLogoFromType.ts` to return new icon path, update `src/entity/storages/models/StorageType.ts` to include new type, and update `src/entity/storages/models/getStorageNameFromType.ts` to return new name.
+
+3. Add UI components to manage your storage:
+   - `src/features/storages/ui/edit/storages/Edit{StorageName}Component.tsx` (for editing)
+   - `src/features/storages/ui/show/storages/Show{StorageName}Component.tsx` (for display)
+
+4. Update main components to handle the new storage type:
+   - `EditStorageComponent.tsx` - add import and component rendering
+   - `ShowStorageComponent.tsx` - add import and component rendering
+
+5. Make sure everything is working as expected.

docker-compose.yml.example

@@ -16,27 +16,4 @@ services:
     volumes:
       - ./postgresus-data:/postgresus-data
     container_name: postgresus-local
-    depends_on:
-      postgresus-db:
-        condition: service_healthy
-    restart: unless-stopped
-
-  postgresus-db:
-    image: postgres:17
-    # we use default values, but do not expose
-    # PostgreSQL ports so it is safe
-    environment:
-      - POSTGRES_DB=postgresus
-      - POSTGRES_USER=postgres
-      - POSTGRES_PASSWORD=Q1234567
-    volumes:
-      - ./pgdata:/var/lib/postgresql/data
-    container_name: postgresus-db
-    command: -p 5437
-    shm_size: 10gb
-    healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U postgres -d postgresus -p 5437"]
-      interval: 5s
-      timeout: 5s
-      retries: 5
-    restart: unless-stopped
+    restart: unless-stopped

frontend/README.md

@@ -1,54 +1,39 @@
-# React + TypeScript + Vite
+# Frontend Development
 
-This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
+## Development
 
-Currently, two official plugins are available:
+To run the development server:
 
-- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react) uses [Babel](https://babeljs.io/) for Fast Refresh
-- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react-swc) uses [SWC](https://swc.rs/) for Fast Refresh
-
-## Expanding the ESLint configuration
-
-If you are developing a production application, we recommend updating the configuration to enable type-aware lint rules:
-
-```js
-export default tseslint.config({
-  extends: [
-    // Remove ...tseslint.configs.recommended and replace with this
-    ...tseslint.configs.recommendedTypeChecked,
-    // Alternatively, use this for stricter rules
-    ...tseslint.configs.strictTypeChecked,
-    // Optionally, add this for stylistic rules
-    ...tseslint.configs.stylisticTypeChecked,
-  ],
-  languageOptions: {
-    // other options...
-    parserOptions: {
-      project: ['./tsconfig.node.json', './tsconfig.app.json'],
-      tsconfigRootDir: import.meta.dirname,
-    },
-  },
-});
+```bash
+npm run dev
 ```
 
-You can also install [eslint-plugin-react-x](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-x) and [eslint-plugin-react-dom](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-dom) for React-specific lint rules:
+## Build
 
-```js
-// eslint.config.js
-import reactDom from 'eslint-plugin-react-dom';
-import reactX from 'eslint-plugin-react-x';
+To build the project for production:
 
-export default tseslint.config({
-  plugins: {
-    // Add the react-x and react-dom plugins
-    'react-x': reactX,
-    'react-dom': reactDom,
-  },
-  rules: {
-    // other rules...
-    // Enable its recommended typescript rules
-    ...reactX.configs['recommended-typescript'].rules,
-    ...reactDom.configs.recommended.rules,
-  },
-});
+```bash
+npm run build
 ```
+
+This will compile TypeScript and create an optimized production build.
+
+## Code Quality
+
+### Linting
+
+To check for linting errors:
+
+```bash
+npm run lint
+```
+
+### Formatting
+
+To format code using Prettier:
+
+```bash
+npm run format
+```
+
+This will automatically format all TypeScript, JavaScript, JSON, CSS, and Markdown files.

frontend/package-lock.json

@@ -15,6 +15,7 @@
         "react-dom": "^19.1.0",
         "react-github-btn": "^1.4.0",
         "react-router": "^7.6.0",
+        "recharts": "^3.2.0",
         "tailwindcss": "^4.1.7"
       },
       "devDependencies": {
@@ -1315,6 +1316,32 @@
         "react-dom": ">=16.9.0"
       }
     },
+    "node_modules/@reduxjs/toolkit": {
+      "version": "2.9.0",
+      "resolved": "https://registry.npmjs.org/@reduxjs/toolkit/-/toolkit-2.9.0.tgz",
+      "integrity": "sha512-fSfQlSRu9Z5yBkvsNhYF2rPS8cGXn/TZVrlwN1948QyZ8xMZ0JvP50S2acZNaf+o63u6aEeMjipFyksjIcWrog==",
+      "license": "MIT",
+      "dependencies": {
+        "@standard-schema/spec": "^1.0.0",
+        "@standard-schema/utils": "^0.3.0",
+        "immer": "^10.0.3",
+        "redux": "^5.0.1",
+        "redux-thunk": "^3.1.0",
+        "reselect": "^5.1.0"
+      },
+      "peerDependencies": {
+        "react": "^16.9.0 || ^17.0.0 || ^18 || ^19",
+        "react-redux": "^7.2.1 || ^8.1.3 || ^9.0.0"
+      },
+      "peerDependenciesMeta": {
+        "react": {
+          "optional": true
+        },
+        "react-redux": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/@rollup/rollup-android-arm-eabi": {
       "version": "4.41.0",
       "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.41.0.tgz",
@@ -1575,6 +1602,18 @@
         "win32"
       ]
     },
+    "node_modules/@standard-schema/spec": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.0.0.tgz",
+      "integrity": "sha512-m2bOd0f2RT9k8QJx1JN85cZYyH1RqFBdlwtkSlf4tBDYLCiiZnv1fIIwacK6cqwXavOydf0NPToMQgpKq+dVlA==",
+      "license": "MIT"
+    },
+    "node_modules/@standard-schema/utils": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/@standard-schema/utils/-/utils-0.3.0.tgz",
+      "integrity": "sha512-e7Mew686owMaPJVNNLs55PUvgz371nKgwsc4vxE49zsODpJEnxgxRo2y/OKrqueavXgZNMDVj3DdHFlaSAeU8g==",
+      "license": "MIT"
+    },
     "node_modules/@tailwindcss/node": {
       "version": "4.1.7",
       "resolved": "https://registry.npmjs.org/@tailwindcss/node/-/node-4.1.7.tgz",
@@ -1917,6 +1956,69 @@
         "@babel/types": "^7.20.7"
       }
     },
+    "node_modules/@types/d3-array": {
+      "version": "3.2.2",
+      "resolved": "https://registry.npmjs.org/@types/d3-array/-/d3-array-3.2.2.tgz",
+      "integrity": "sha512-hOLWVbm7uRza0BYXpIIW5pxfrKe0W+D5lrFiAEYR+pb6w3N2SwSMaJbXdUfSEv+dT4MfHBLtn5js0LAWaO6otw==",
+      "license": "MIT"
+    },
+    "node_modules/@types/d3-color": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/@types/d3-color/-/d3-color-3.1.3.tgz",
+      "integrity": "sha512-iO90scth9WAbmgv7ogoq57O9YpKmFBbmoEoCHDB2xMBY0+/KVrqAaCDyCE16dUspeOvIxFFRI+0sEtqDqy2b4A==",
+      "license": "MIT"
+    },
+    "node_modules/@types/d3-ease": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/@types/d3-ease/-/d3-ease-3.0.2.tgz",
+      "integrity": "sha512-NcV1JjO5oDzoK26oMzbILE6HW7uVXOHLQvHshBUW4UMdZGfiY6v5BeQwh9a9tCzv+CeefZQHJt5SRgK154RtiA==",
+      "license": "MIT"
+    },
+    "node_modules/@types/d3-interpolate": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/@types/d3-interpolate/-/d3-interpolate-3.0.4.tgz",
+      "integrity": "sha512-mgLPETlrpVV1YRJIglr4Ez47g7Yxjl1lj7YKsiMCb27VJH9W8NVM6Bb9d8kkpG/uAQS5AmbA48q2IAolKKo1MA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/d3-color": "*"
+      }
+    },
+    "node_modules/@types/d3-path": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/@types/d3-path/-/d3-path-3.1.1.tgz",
+      "integrity": "sha512-VMZBYyQvbGmWyWVea0EHs/BwLgxc+MKi1zLDCONksozI4YJMcTt8ZEuIR4Sb1MMTE8MMW49v0IwI5+b7RmfWlg==",
+      "license": "MIT"
+    },
+    "node_modules/@types/d3-scale": {
+      "version": "4.0.9",
+      "resolved": "https://registry.npmjs.org/@types/d3-scale/-/d3-scale-4.0.9.tgz",
+      "integrity": "sha512-dLmtwB8zkAeO/juAMfnV+sItKjlsw2lKdZVVy6LRr0cBmegxSABiLEpGVmSJJ8O08i4+sGR6qQtb6WtuwJdvVw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/d3-time": "*"
+      }
+    },
+    "node_modules/@types/d3-shape": {
+      "version": "3.1.7",
+      "resolved": "https://registry.npmjs.org/@types/d3-shape/-/d3-shape-3.1.7.tgz",
+      "integrity": "sha512-VLvUQ33C+3J+8p+Daf+nYSOsjB4GXp19/S/aGo60m9h1v6XaxjiT82lKVWJCfzhtuZ3yD7i/TPeC/fuKLLOSmg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/d3-path": "*"
+      }
+    },
+    "node_modules/@types/d3-time": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/@types/d3-time/-/d3-time-3.0.4.tgz",
+      "integrity": "sha512-yuzZug1nkAAaBlBBikKZTgzCeA+k1uy4ZFwWANOfKw5z5LRhV0gNA7gNkKm7HoK+HRN0wX3EkxGk0fpbWhmB7g==",
+      "license": "MIT"
+    },
+    "node_modules/@types/d3-timer": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/@types/d3-timer/-/d3-timer-3.0.2.tgz",
+      "integrity": "sha512-Ps3T8E8dZDam6fUyNiMkekK3XUsaUEik+idO9/YjPtfj2qruF8tFBXS7XhtE4iIXBLxhmLjP3SXpLhVf21I9Lw==",
+      "license": "MIT"
+    },
     "node_modules/@types/estree": {
       "version": "1.0.7",
       "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.7.tgz",
@@ -1934,7 +2036,7 @@
       "version": "19.1.4",
       "resolved": "https://registry.npmjs.org/@types/react/-/react-19.1.4.tgz",
       "integrity": "sha512-EB1yiiYdvySuIITtD5lhW4yPyJ31RkJkkDw794LaQYrxCSaQV/47y5o1FMC4zF9ZyjUjzJMZwbovEnT5yHTW6g==",
-      "dev": true,
+      "devOptional": true,
       "license": "MIT",
       "dependencies": {
         "csstype": "^3.0.2"
@@ -1950,6 +2052,12 @@
         "@types/react": "^19.0.0"
       }
     },
+    "node_modules/@types/use-sync-external-store": {
+      "version": "0.0.6",
+      "resolved": "https://registry.npmjs.org/@types/use-sync-external-store/-/use-sync-external-store-0.0.6.tgz",
+      "integrity": "sha512-zFDAD+tlpf2r4asuHEj0XH6pY6i0g5NeAHPn+15wk3BV6JA69eERFXC1gyGThDkVa1zCyKr5jox1+2LbV/AMLg==",
+      "license": "MIT"
+    },
     "node_modules/@typescript-eslint/eslint-plugin": {
       "version": "8.32.1",
       "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.32.1.tgz",
@@ -2666,6 +2774,15 @@
       "integrity": "sha512-saHYOzhIQs6wy2sVxTM6bUDsQO4F50V9RQ22qBpEdCW+I+/Wmke2HOl6lS6dTpdxVhb88/I6+Hs+438c3lfUow==",
       "license": "MIT"
     },
+    "node_modules/clsx": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/clsx/-/clsx-2.1.1.tgz",
+      "integrity": "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
     "node_modules/color-convert": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
@@ -2745,6 +2862,127 @@
       "integrity": "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==",
       "license": "MIT"
     },
+    "node_modules/d3-array": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/d3-array/-/d3-array-3.2.4.tgz",
+      "integrity": "sha512-tdQAmyA18i4J7wprpYq8ClcxZy3SC31QMeByyCFyRt7BVHdREQZ5lpzoe5mFEYZUWe+oq8HBvk9JjpibyEV4Jg==",
+      "license": "ISC",
+      "dependencies": {
+        "internmap": "1 - 2"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-color": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/d3-color/-/d3-color-3.1.0.tgz",
+      "integrity": "sha512-zg/chbXyeBtMQ1LbD/WSoW2DpC3I0mpmPdW+ynRTj/x2DAWYrIY7qeZIHidozwV24m4iavr15lNwIwLxRmOxhA==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-ease": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/d3-ease/-/d3-ease-3.0.1.tgz",
+      "integrity": "sha512-wR/XK3D3XcLIZwpbvQwQ5fK+8Ykds1ip7A2Txe0yxncXSdq1L9skcG7blcedkOX+ZcgxGAmLX1FrRGbADwzi0w==",
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-format": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/d3-format/-/d3-format-3.1.0.tgz",
+      "integrity": "sha512-YyUI6AEuY/Wpt8KWLgZHsIU86atmikuoOmCfommt0LYHiQSPjvX2AcFc38PX0CBpr2RCyZhjex+NS/LPOv6YqA==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-interpolate": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/d3-interpolate/-/d3-interpolate-3.0.1.tgz",
+      "integrity": "sha512-3bYs1rOD33uo8aqJfKP3JWPAibgw8Zm2+L9vBKEHJ2Rg+viTR7o5Mmv5mZcieN+FRYaAOWX5SJATX6k1PWz72g==",
+      "license": "ISC",
+      "dependencies": {
+        "d3-color": "1 - 3"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-path": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/d3-path/-/d3-path-3.1.0.tgz",
+      "integrity": "sha512-p3KP5HCf/bvjBSSKuXid6Zqijx7wIfNW+J/maPs+iwR35at5JCbLUT0LzF1cnjbCHWhqzQTIN2Jpe8pRebIEFQ==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-scale": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/d3-scale/-/d3-scale-4.0.2.tgz",
+      "integrity": "sha512-GZW464g1SH7ag3Y7hXjf8RoUuAFIqklOAq3MRl4OaWabTFJY9PN/E1YklhXLh+OQ3fM9yS2nOkCoS+WLZ6kvxQ==",
+      "license": "ISC",
+      "dependencies": {
+        "d3-array": "2.10.0 - 3",
+        "d3-format": "1 - 3",
+        "d3-interpolate": "1.2.0 - 3",
+        "d3-time": "2.1.1 - 3",
+        "d3-time-format": "2 - 4"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-shape": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/d3-shape/-/d3-shape-3.2.0.tgz",
+      "integrity": "sha512-SaLBuwGm3MOViRq2ABk3eLoxwZELpH6zhl3FbAoJ7Vm1gofKx6El1Ib5z23NUEhF9AsGl7y+dzLe5Cw2AArGTA==",
+      "license": "ISC",
+      "dependencies": {
+        "d3-path": "^3.1.0"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-time": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/d3-time/-/d3-time-3.1.0.tgz",
+      "integrity": "sha512-VqKjzBLejbSMT4IgbmVgDjpkYrNWUYJnbCGo874u7MMKIWsILRX+OpX/gTk8MqjpT1A/c6HY2dCA77ZN0lkQ2Q==",
+      "license": "ISC",
+      "dependencies": {
+        "d3-array": "2 - 3"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-time-format": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/d3-time-format/-/d3-time-format-4.1.0.tgz",
+      "integrity": "sha512-dJxPBlzC7NugB2PDLwo9Q8JiTR3M3e4/XANkreKSUxF8vvXKqm1Yfq4Q5dl8budlunRVlUUaDUgFt7eA8D6NLg==",
+      "license": "ISC",
+      "dependencies": {
+        "d3-time": "1 - 3"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-timer": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/d3-timer/-/d3-timer-3.0.1.tgz",
+      "integrity": "sha512-ndfJ/JxxMd3nw31uyKoY2naivF+r29V+Lc0svZxe1JvvIRmi8hUsrMvdOwgS1o6uBHmiz91geQ0ylPP0aj1VUA==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=12"
+      }
+    },
     "node_modules/data-view-buffer": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/data-view-buffer/-/data-view-buffer-1.0.2.tgz",
@@ -2823,6 +3061,12 @@
         }
       }
     },
+    "node_modules/decimal.js-light": {
+      "version": "2.5.1",
+      "resolved": "https://registry.npmjs.org/decimal.js-light/-/decimal.js-light-2.5.1.tgz",
+      "integrity": "sha512-qIMFpTMZmny+MMIitAB6D7iVPEorVw6YQRWkvarTkT4tBeSLLiHzcwj6q0MmYSFCiVpiqPJTJEYIrpcPzVEIvg==",
+      "license": "MIT"
+    },
     "node_modules/deep-is": {
       "version": "0.1.4",
       "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
@@ -3097,6 +3341,16 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/es-toolkit": {
+      "version": "1.39.10",
+      "resolved": "https://registry.npmjs.org/es-toolkit/-/es-toolkit-1.39.10.tgz",
+      "integrity": "sha512-E0iGnTtbDhkeczB0T+mxmoVlT4YNweEKBLq7oaU4p11mecdsZpNWOglI4895Vh4usbQ+LsJiuLuI2L0Vdmfm2w==",
+      "license": "MIT",
+      "workspaces": [
+        "docs",
+        "benchmarks"
+      ]
+    },
     "node_modules/esbuild": {
       "version": "0.25.4",
       "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.4.tgz",
@@ -3371,6 +3625,12 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/eventemitter3": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-5.0.1.tgz",
+      "integrity": "sha512-GWkBvjiSZK87ELrYOSESUYeVIc9mvLLf/nXalMOS5dYrgZq9o5OVkbZAVM06CVxYsCwH9BDZFPlQTlPA1j4ahA==",
+      "license": "MIT"
+    },
     "node_modules/fast-deep-equal": {
       "version": "3.1.3",
       "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
@@ -3813,6 +4073,16 @@
         "node": ">= 4"
       }
     },
+    "node_modules/immer": {
+      "version": "10.1.3",
+      "resolved": "https://registry.npmjs.org/immer/-/immer-10.1.3.tgz",
+      "integrity": "sha512-tmjF/k8QDKydUlm3mZU+tjM6zeq9/fFpPqH9SzWmBnVVKsPBg/V66qsMwb3/Bo90cgUN+ghdVBess+hPsxUyRw==",
+      "license": "MIT",
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/immer"
+      }
+    },
     "node_modules/import-fresh": {
       "version": "3.3.1",
       "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz",
@@ -3855,6 +4125,15 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/internmap": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/internmap/-/internmap-2.0.3.tgz",
+      "integrity": "sha512-5Hh7Y1wQbvY5ooGgPbDaL5iYLAPzMTUrjMulskHLH6wnv/A+1q5rgEaiuqEjB+oxGXIVZs1FF+R/KPN3ZSQYYg==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=12"
+      }
+    },
     "node_modules/is-array-buffer": {
       "version": "3.0.5",
       "resolved": "https://registry.npmjs.org/is-array-buffer/-/is-array-buffer-3.0.5.tgz",
@@ -5879,9 +6158,31 @@
       "version": "16.13.1",
       "resolved": "https://registry.npmjs.org/react-is/-/react-is-16.13.1.tgz",
       "integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==",
-      "dev": true,
       "license": "MIT"
     },
+    "node_modules/react-redux": {
+      "version": "9.2.0",
+      "resolved": "https://registry.npmjs.org/react-redux/-/react-redux-9.2.0.tgz",
+      "integrity": "sha512-ROY9fvHhwOD9ySfrF0wmvu//bKCQ6AeZZq1nJNtbDC+kk5DuSuNX/n6YWYF/SYy7bSba4D4FSz8DJeKY/S/r+g==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/use-sync-external-store": "^0.0.6",
+        "use-sync-external-store": "^1.4.0"
+      },
+      "peerDependencies": {
+        "@types/react": "^18.2.25 || ^19",
+        "react": "^18.0 || ^19",
+        "redux": "^5.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        },
+        "redux": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/react-refresh": {
       "version": "0.17.0",
       "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.17.0.tgz",
@@ -5914,6 +6215,48 @@
         }
       }
     },
+    "node_modules/recharts": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/recharts/-/recharts-3.2.0.tgz",
+      "integrity": "sha512-fX0xCgNXo6mag9wz3oLuANR+dUQM4uIlTYBGTGq9CBRgW/8TZPzqPGYs5NTt8aENCf+i1CI8vqxT1py8L/5J2w==",
+      "license": "MIT",
+      "dependencies": {
+        "@reduxjs/toolkit": "1.x.x || 2.x.x",
+        "clsx": "^2.1.1",
+        "decimal.js-light": "^2.5.1",
+        "es-toolkit": "^1.39.3",
+        "eventemitter3": "^5.0.1",
+        "immer": "^10.1.1",
+        "react-redux": "8.x.x || 9.x.x",
+        "reselect": "5.1.1",
+        "tiny-invariant": "^1.3.3",
+        "use-sync-external-store": "^1.2.2",
+        "victory-vendor": "^37.0.2"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
+        "react-dom": "^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
+        "react-is": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
+      }
+    },
+    "node_modules/redux": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/redux/-/redux-5.0.1.tgz",
+      "integrity": "sha512-M9/ELqF6fy8FwmkpnF0S3YKOqMyoWJ4+CS5Efg2ct3oY9daQvd/Pc71FpGZsVsbl3Cpb+IIcjBDUnnyBdQbq4w==",
+      "license": "MIT"
+    },
+    "node_modules/redux-thunk": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/redux-thunk/-/redux-thunk-3.1.0.tgz",
+      "integrity": "sha512-NW2r5T6ksUKXCabzhL9z+h206HQw/NJkcLm1GPImRQ8IzfXwRGqjVhKJGauHirT0DAuyy6hjdnMZaRoAcy0Klw==",
+      "license": "MIT",
+      "peerDependencies": {
+        "redux": "^5.0.0"
+      }
+    },
     "node_modules/reflect.getprototypeof": {
       "version": "1.0.10",
       "resolved": "https://registry.npmjs.org/reflect.getprototypeof/-/reflect.getprototypeof-1.0.10.tgz",
@@ -5958,6 +6301,12 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/reselect": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/reselect/-/reselect-5.1.1.tgz",
+      "integrity": "sha512-K/BG6eIky/SBpzfHZv/dd+9JBFiS4SWV7FIujVyJRux6e45+73RaUHXLmIR1f7WOMaQ0U1km6qwklRQxpJJY0w==",
+      "license": "MIT"
+    },
     "node_modules/resize-observer-polyfill": {
       "version": "1.5.1",
       "resolved": "https://registry.npmjs.org/resize-observer-polyfill/-/resize-observer-polyfill-1.5.1.tgz",
@@ -6508,6 +6857,12 @@
         "node": ">=12.22"
       }
     },
+    "node_modules/tiny-invariant": {
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/tiny-invariant/-/tiny-invariant-1.3.3.tgz",
+      "integrity": "sha512-+FbBPE1o9QAYvviau/qC5SE3caw21q3xkvWKBtja5vgqOWIHHJ3ioaq1VPfn/Szqctz2bU/oYeKd9/z5BL+PVg==",
+      "license": "MIT"
+    },
     "node_modules/tinyglobby": {
       "version": "0.2.13",
       "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.13.tgz",
@@ -6770,6 +7125,37 @@
         "punycode": "^2.1.0"
       }
     },
+    "node_modules/use-sync-external-store": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/use-sync-external-store/-/use-sync-external-store-1.5.0.tgz",
+      "integrity": "sha512-Rb46I4cGGVBmjamjphe8L/UnvJD+uPPtTkNvX5mZgqdbavhI4EbgIWJiIHXJ8bc/i9EQGPRh4DwEURJ552Do0A==",
+      "license": "MIT",
+      "peerDependencies": {
+        "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
+      }
+    },
+    "node_modules/victory-vendor": {
+      "version": "37.3.6",
+      "resolved": "https://registry.npmjs.org/victory-vendor/-/victory-vendor-37.3.6.tgz",
+      "integrity": "sha512-SbPDPdDBYp+5MJHhBCAyI7wKM3d5ivekigc2Dk2s7pgbZ9wIgIBYGVw4zGHBml/qTFbexrofXW6Gu4noGxrOwQ==",
+      "license": "MIT AND ISC",
+      "dependencies": {
+        "@types/d3-array": "^3.0.3",
+        "@types/d3-ease": "^3.0.0",
+        "@types/d3-interpolate": "^3.0.1",
+        "@types/d3-scale": "^4.0.2",
+        "@types/d3-shape": "^3.1.0",
+        "@types/d3-time": "^3.0.0",
+        "@types/d3-timer": "^3.0.0",
+        "d3-array": "^3.1.6",
+        "d3-ease": "^3.0.1",
+        "d3-interpolate": "^3.0.1",
+        "d3-scale": "^4.0.2",
+        "d3-shape": "^3.1.0",
+        "d3-time": "^3.0.0",
+        "d3-timer": "^3.0.1"
+      }
+    },
     "node_modules/vite": {
       "version": "6.3.5",
       "resolved": "https://registry.npmjs.org/vite/-/vite-6.3.5.tgz",

frontend/package.json

@@ -18,6 +18,7 @@
     "react-dom": "^19.1.0",
     "react-github-btn": "^1.4.0",
     "react-router": "^7.6.0",
+    "recharts": "^3.2.0",
     "tailwindcss": "^4.1.7"
   },
   "devDependencies": {

frontend/public/icons/notifiers/teams.svg

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="utf-8"?><!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
+<svg width="800px" height="800px" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="none"><path fill="#5059C9" d="M10.765 6.875h3.616c.342 0 .619.276.619.617v3.288a2.272 2.272 0 01-2.274 2.27h-.01a2.272 2.272 0 01-2.274-2.27V7.199c0-.179.145-.323.323-.323zM13.21 6.225c.808 0 1.464-.655 1.464-1.462 0-.808-.656-1.463-1.465-1.463s-1.465.655-1.465 1.463c0 .807.656 1.462 1.465 1.462z"/><path fill="#7B83EB" d="M8.651 6.225a2.114 2.114 0 002.117-2.112A2.114 2.114 0 008.65 2a2.114 2.114 0 00-2.116 2.112c0 1.167.947 2.113 2.116 2.113zM11.473 6.875h-5.97a.611.611 0 00-.596.625v3.75A3.669 3.669 0 008.488 15a3.669 3.669 0 003.582-3.75V7.5a.611.611 0 00-.597-.625z"/><path fill="#000000" d="M8.814 6.875v5.255a.598.598 0 01-.596.595H5.193a3.951 3.951 0 01-.287-1.476V7.5a.61.61 0 01.597-.624h3.31z" opacity=".1"/><path fill="#000000" d="M8.488 6.875v5.58a.6.6 0 01-.596.595H5.347a3.22 3.22 0 01-.267-.65 3.951 3.951 0 01-.172-1.15V7.498a.61.61 0 01.596-.624h2.985z" opacity=".2"/><path fill="#000000" d="M8.488 6.875v4.93a.6.6 0 01-.596.595H5.08a3.951 3.951 0 01-.172-1.15V7.498a.61.61 0 01.596-.624h2.985z" opacity=".2"/><path fill="#000000" d="M8.163 6.875v4.93a.6.6 0 01-.596.595H5.079a3.951 3.951 0 01-.172-1.15V7.498a.61.61 0 01.596-.624h2.66z" opacity=".2"/><path fill="#000000" d="M8.814 5.195v1.024c-.055.003-.107.006-.163.006-.055 0-.107-.003-.163-.006A2.115 2.115 0 016.593 4.6h1.625a.598.598 0 01.596.594z" opacity=".1"/><path fill="#000000" d="M8.488 5.52v.699a2.115 2.115 0 01-1.79-1.293h1.195a.598.598 0 01.595.594z" opacity=".2"/><path fill="#000000" d="M8.488 5.52v.699a2.115 2.115 0 01-1.79-1.293h1.195a.598.598 0 01.595.594z" opacity=".2"/><path fill="#000000" d="M8.163 5.52v.647a2.115 2.115 0 01-1.465-1.242h.87a.598.598 0 01.595.595z" opacity=".2"/><path fill="url(#microsoft-teams-color-16__paint0_linear_2372_494)" d="M1.597 4.925h5.969c.33 0 .597.267.597.596v5.958a.596.596 0 01-.597.596h-5.97A.596.596 0 011 11.479V5.521c0-.33.267-.596.597-.596z"/><path fill="#ffffff" d="M6.152 7.193H4.959v3.243h-.76V7.193H3.01v-.63h3.141v.63z"/><defs><linearGradient id="microsoft-teams-color-16__paint0_linear_2372_494" x1="2.244" x2="6.906" y1="4.46" y2="12.548" gradientUnits="userSpaceOnUse"><stop stop-color="#5A62C3"/><stop offset=".5" stop-color="#4D55BD"/><stop offset="1" stop-color="#3940AB"/></linearGradient></defs></svg>

frontend/public/icons/storages/nas.svg

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
+<svg fill="#000000" width="800px" height="800px" viewBox="0 0 256 256" id="Flat" xmlns="http://www.w3.org/2000/svg">
+  <g opacity="0.2">
+    <rect x="40" y="144" width="176" height="64" rx="8"/>
+  </g>
+  <g opacity="0.2">
+    <rect x="40" y="48" width="176" height="64" rx="8"/>
+  </g>
+  <path d="M208,136H48a16.01833,16.01833,0,0,0-16,16v48a16.01833,16.01833,0,0,0,16,16H208a16.01833,16.01833,0,0,0,16-16V152A16.01833,16.01833,0,0,0,208,136Zm0,64H48V152H208l.01025,47.99951Zm0-160H48A16.01833,16.01833,0,0,0,32,56v48a16.01833,16.01833,0,0,0,16,16H208a16.01833,16.01833,0,0,0,16-16V56A16.01833,16.01833,0,0,0,208,40Zm0,64H48V56H208l.01025,47.99951ZM192,80a12,12,0,1,1-12-12A12.01375,12.01375,0,0,1,192,80Zm0,96a12,12,0,1,1-12-12A12.01375,12.01375,0,0,1,192,176Z"/>

frontend/src/constants.ts

@@ -12,3 +12,5 @@ export function getApplicationServer() {
 }
 
 export const GOOGLE_DRIVE_OAUTH_REDIRECT_URL = 'https://postgresus.com/storages/google-oauth';
+
+export const APP_VERSION = (import.meta.env.VITE_APP_VERSION as string) || 'dev';

frontend/src/entity/databases/api/databaseApi.ts

@@ -48,6 +48,14 @@ export const databaseApi = {
     );
   },
 
+  async copyDatabase(id: string) {
+    const requestOptions: RequestOptions = new RequestOptions();
+    return apiHelper.fetchPostJson<Database>(
+      `${getApplicationServer()}/api/v1/databases/${id}/copy`,
+      requestOptions,
+    );
+  },
+
   async testDatabaseConnection(id: string) {
     const requestOptions: RequestOptions = new RequestOptions();
     return apiHelper.fetchPostJson(

frontend/src/entity/databases/model/postgresql/PostgresqlVersion.ts

@@ -4,4 +4,5 @@ export enum PostgresqlVersion {
   PostgresqlVersion15 = '15',
   PostgresqlVersion16 = '16',
   PostgresqlVersion17 = '17',
+  PostgresqlVersion18 = '18',
 }

frontend/src/entity/notifiers/index.ts

@@ -17,3 +17,6 @@ export { validateSlackNotifier } from './models/slack/validateSlackNotifier';
 
 export type { DiscordNotifier } from './models/discord/DiscordNotifier';
 export { validateDiscordNotifier } from './models/discord/validateDiscordNotifier';
+
+export type { TeamsNotifier } from './models/teams/TeamsNotifier';
+export { validateTeamsNotifier } from './models/teams/validateTeamsNotifier';

frontend/src/entity/notifiers/models/Notifier.ts

@@ -2,6 +2,7 @@ import type { NotifierType } from './NotifierType';
 import type { DiscordNotifier } from './discord/DiscordNotifier';
 import type { EmailNotifier } from './email/EmailNotifier';
 import type { SlackNotifier } from './slack/SlackNotifier';
+import type { TeamsNotifier } from './teams/TeamsNotifier';
 import type { TelegramNotifier } from './telegram/TelegramNotifier';
 import type { WebhookNotifier } from './webhook/WebhookNotifier';
 
@@ -17,4 +18,5 @@ export interface Notifier {
   webhookNotifier?: WebhookNotifier;
   slackNotifier?: SlackNotifier;
   discordNotifier?: DiscordNotifier;
+  teamsNotifier?: TeamsNotifier;
 }

frontend/src/entity/notifiers/models/NotifierType.ts

@@ -4,4 +4,5 @@ export enum NotifierType {
   WEBHOOK = 'WEBHOOK',
   SLACK = 'SLACK',
   DISCORD = 'DISCORD',
+  TEAMS = 'TEAMS',
 }

frontend/src/entity/notifiers/models/getNotifierLogoFromType.ts

@@ -12,6 +12,8 @@ export const getNotifierLogoFromType = (type: NotifierType) => {
       return '/icons/notifiers/slack.svg';
     case NotifierType.DISCORD:
       return '/icons/notifiers/discord.svg';
+    case NotifierType.TEAMS:
+      return '/icons/notifiers/teams.svg';
     default:
       return '';
   }

frontend/src/entity/notifiers/models/getNotifierNameFromType.ts

@@ -10,6 +10,10 @@ export const getNotifierNameFromType = (type: NotifierType) => {
       return 'Webhook';
     case NotifierType.SLACK:
       return 'Slack';
+    case NotifierType.DISCORD:
+      return 'Discord';
+    case NotifierType.TEAMS:
+      return 'Teams';
     default:
       return '';
   }

frontend/src/entity/notifiers/models/teams/TeamsNotifier.ts

@@ -0,0 +1,7 @@
+export interface TeamsNotifier {
+  /** Power Automate HTTP endpoint:
+   *  trigger = "When an HTTP request is received"
+   *  e.g. https://prod-00.westeurope.logic.azure.com/workflows/...
+   */
+  powerAutomateUrl: string;
+}

frontend/src/entity/notifiers/models/teams/validateTeamsNotifier.ts

@@ -0,0 +1,16 @@
+import type { TeamsNotifier } from './TeamsNotifier';
+
+export const validateTeamsNotifier = (notifier: TeamsNotifier): boolean => {
+  if (!notifier?.powerAutomateUrl) {
+    return false;
+  }
+
+  try {
+    const u = new URL(notifier.powerAutomateUrl);
+    if (u.protocol !== 'http:' && u.protocol !== 'https:') return false;
+  } catch {
+    return false;
+  }
+
+  return true;
+};

frontend/src/entity/notifiers/models/telegram/TelegramNotifier.ts

@@ -1,4 +1,8 @@
 export interface TelegramNotifier {
   botToken: string;
   targetChatId: string;
+  threadId?: number;
+
+  // temp field
+  isSendToThreadEnabled?: boolean;
 }

frontend/src/entity/notifiers/models/telegram/validateTelegramNotifier.ts

@@ -9,5 +9,10 @@ export const validateTelegramNotifier = (notifier: TelegramNotifier): boolean =>
     return false;
   }
 
+  // If thread is enabled, thread ID must be present and valid
+  if (notifier.isSendToThreadEnabled && (!notifier.threadId || notifier.threadId <= 0)) {
+    return false;
+  }
+
   return true;
 };

frontend/src/entity/storages/index.ts

@@ -3,6 +3,7 @@ export { type Storage } from './models/Storage';
 export { StorageType } from './models/StorageType';
 export { type LocalStorage } from './models/LocalStorage';
 export { type S3Storage } from './models/S3Storage';
+export { type NASStorage } from './models/NASStorage';
 export { getStorageLogoFromType } from './models/getStorageLogoFromType';
 export { getStorageNameFromType } from './models/getStorageNameFromType';
 export { type GoogleDriveStorage } from './models/GoogleDriveStorage';

frontend/src/entity/storages/models/NASStorage.ts

@@ -0,0 +1,10 @@
+export interface NASStorage {
+  host: string;
+  port: number;
+  share: string;
+  username: string;
+  password: string;
+  useSsl: boolean;
+  domain?: string;
+  path?: string;
+}

frontend/src/entity/storages/models/Storage.ts

@@ -1,5 +1,6 @@
 import type { GoogleDriveStorage } from './GoogleDriveStorage';
 import type { LocalStorage } from './LocalStorage';
+import type { NASStorage } from './NASStorage';
 import type { S3Storage } from './S3Storage';
 import type { StorageType } from './StorageType';
 
@@ -13,4 +14,5 @@ export interface Storage {
   localStorage?: LocalStorage;
   s3Storage?: S3Storage;
   googleDriveStorage?: GoogleDriveStorage;
+  nasStorage?: NASStorage;
 }

frontend/src/entity/storages/models/StorageType.ts

@@ -2,4 +2,5 @@ export enum StorageType {
   LOCAL = 'LOCAL',
   S3 = 'S3',
   GOOGLE_DRIVE = 'GOOGLE_DRIVE',
+  NAS = 'NAS',
 }