chore: bump version to 1.0.115 (backend + frontend)

Added comprehensive logo customization features for gallery views:
- Logo size options (small, medium, large, xlarge, custom)
- Logo position control (left, center, right)
- Display mode settings (logo only, text only, logo and text)
- Visibility controls for header and hero sections
- Custom height configuration for fine-tuning

Changes:
- Added database migration for 6 new logo customization settings
- Extended backend APIs to handle logo customization fields
- Updated GalleryLayout.tsx with dynamic logo rendering logic
- Added logo upload functionality to BrandingPage.tsx
- Extended settings service with logo customization types

This addresses the issue where the gallery logo was "very large and centered"
by providing full control over logo appearance and positioning.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

.claudedocs/scans/security-20250713.md

@@ -1,286 +0,0 @@
-# Security Scan Report - Wedding Photo Sharing Application
-**Date**: July 13, 2025  
-**Scanner**: Claude Security Audit with --security --validate flags  
-**Overall Risk Level**: MEDIUM-HIGH  
-
-## Executive Summary
-
-The wedding photo sharing application demonstrates strong security fundamentals with comprehensive input validation, proper authentication mechanisms, and good file security practices. However, several critical issues require immediate attention, particularly around hardcoded secrets, token storage, and Content Security Policy configuration.
-
-### Security Score: 6.5/10
-
-**Strengths**: Excellent input validation, parameterized queries, file security, rate limiting  
-**Critical Issues**: Hardcoded JWT secrets, localStorage token storage, weak CSP, console logging in production
-
----
-
-## 🔴 CRITICAL FINDINGS (Immediate Action Required)
-
-### 1. Hardcoded JWT Secret in Development
-- **Location**: Backend `.env` file
-- **Risk**: Token forgery, authentication bypass
-- **Impact**: Complete authentication compromise
-- **Remediation**: 
-  ```bash
-  # Generate secure secret
-  openssl rand -base64 32
-  # Never commit to repository
-  echo ".env" >> .gitignore
-  ```
-
-### 2. Gallery Tokens in localStorage
-- **Location**: Frontend `api.ts` and auth contexts
-- **Risk**: XSS token theft
-- **Impact**: Gallery access compromise
-- **Remediation**: Move to httpOnly cookies:
-  ```typescript
-  Cookies.set(`gallery_token_${slug}`, token, {
-    httpOnly: true,
-    secure: true,
-    sameSite: 'strict'
-  });
-  ```
-
-### 3. Weak Content Security Policy
-- **Location**: Frontend `nginx.conf`
-- **Risk**: XSS, code injection
-- **Current**: `unsafe-inline` and `unsafe-eval` allowed
-- **Remediation**: Implement strict CSP (see detailed recommendations below)
-
----
-
-## 🟠 HIGH SEVERITY FINDINGS
-
-### 1. Console Logging in Production
-- **Locations**: 61 instances across frontend
-- **Risk**: Information disclosure
-- **Impact**: Leaking sensitive data, debugging info
-- **Remediation**: Implement environment-aware logging
-
-### 2. Token Revocation Vulnerability
-- **Location**: Backend `tokenRevocation.js`
-- **Risk**: Token manipulation
-- **Impact**: Bypass revocation checks
-- **Remediation**: Verify token signature before decoding
-
-### 3. Source Maps in Production
-- **Location**: Frontend build configuration
-- **Risk**: Source code exposure
-- **Impact**: Reveals application structure
-- **Remediation**: Disable in production builds
-
-### 4. Missing Security Headers
-- **Location**: nginx configuration
-- **Missing**: HSTS, Permissions-Policy
-- **Impact**: Various client-side attacks
-- **Remediation**: Add comprehensive security headers
-
----
-
-## 🟡 MEDIUM SEVERITY FINDINGS
-
-### 1. Rate Limiting Bypass Potential
-- **Location**: Backend rate limiter
-- **Risk**: DoS attacks
-- **Current**: JWT validation in rate limiter
-- **Remediation**: Use IP-based limiting only
-
-### 2. Incomplete SQL Injection Protection
-- **Location**: Complex dashboard queries
-- **Risk**: Potential injection in edge cases
-- **Current**: Mostly parameterized
-- **Remediation**: Use query builder exclusively
-
-### 3. Session Management
-- **Issue**: No gallery token invalidation on password change
-- **Risk**: Persistent access after compromise
-- **Remediation**: Implement token revocation
-
-### 4. Path Traversal in Gallery Slugs
-- **Location**: Frontend gallery routes
-- **Risk**: Directory traversal attempts
-- **Remediation**: Validate and sanitize slugs
-
----
-
-## 🟢 LOW SEVERITY FINDINGS
-
-### 1. Verbose Error Messages
-- **Location**: Multiple API endpoints
-- **Risk**: Information disclosure
-- **Remediation**: Generic client errors, detailed server logs
-
-### 2. Weak Gallery Passwords
-- **Current**: zxcvbn score 2/4 allowed
-- **Risk**: Brute force attacks
-- **Remediation**: Increase to score 3/4
-
-### 3. Missing File Size Validation
-- **Location**: Frontend upload components
-- **Risk**: DoS via large uploads
-- **Remediation**: Add client-side size checks
-
----
-
-## ✅ SECURITY STRENGTHS
-
-### Authentication & Authorization
-- JWT with proper expiration (24h/7d)
-- Token type validation
-- IP tracking and validation
-- Password change detection
-- Token revocation system
-- Bcrypt with 12 rounds
-- zxcvbn password strength checking
-
-### Input Validation & SQL Security
-- express-validator on all endpoints
-- Parameterized queries via Knex
-- SQL injection protection utilities
-- Path traversal prevention
-- Comprehensive input sanitization
-
-### File Security
-- Magic number verification
-- MIME type validation
-- Safe filename generation
-- Directory traversal protection
-- File extension whitelist
-
-### Rate Limiting & DoS Protection
-- General: 100 req/15min
-- Auth endpoints: 5 req/15min
-- Account lockout after failed attempts
-- Suspicious activity detection
-
-### Frontend Security
-- React's built-in XSS protection
-- DOMPurify for HTML content
-- No eval() or innerHTML usage
-- Proper error boundaries
-- ReCAPTCHA integration
-
----
-
-## 📊 DEPENDENCY ANALYSIS
-
-### Current Status
-- **Backend**: 0 vulnerabilities (691 packages)
-- **Frontend**: 0 vulnerabilities (434 packages)
-
-### Recommended Updates
-1. **bcrypt** 5.1.1 → 6.0.0 (performance, compatibility)
-2. **helmet** 7.2.0 → 8.1.0 (new security features)
-3. **@tiptap** 2.x → 3.x (security improvements)
-
-### Supply Chain Assessment
-- All major dependencies from trusted sources
-- No typosquatting detected
-- Regular maintenance observed
-- MIT/ISC/Apache licenses only
-
----
-
-## 🛠️ REMEDIATION PLAN
-
-### Phase 1: Critical (Within 24 hours)
-1. Replace hardcoded JWT secret with secure random value
-2. Move gallery tokens from localStorage to httpOnly cookies
-3. Implement strict CSP without unsafe-eval
-4. Remove or wrap console.log statements
-
-### Phase 2: High Priority (Within 1 week)
-1. Disable source maps in production
-2. Add missing security headers (HSTS, Permissions-Policy)
-3. Fix token revocation vulnerability
-4. Update critical dependencies (bcrypt, helmet)
-
-### Phase 3: Medium Priority (Within 1 month)
-1. Implement comprehensive logging strategy
-2. Add gallery slug validation
-3. Enhance rate limiting logic
-4. Implement session invalidation on password change
-
-### Phase 4: Ongoing
-1. Weekly dependency scanning
-2. Implement security testing in CI/CD
-3. Regular penetration testing
-4. Security awareness training
-
----
-
-## 🔒 RECOMMENDED CSP CONFIGURATION
-
-```nginx
-add_header Content-Security-Policy "
-  default-src 'self';
-  script-src 'self' 'nonce-{RANDOM}' https://www.google.com/recaptcha/ https://www.gstatic.com/recaptcha/;
-  style-src 'self' 'unsafe-inline';
-  img-src 'self' data: blob: https:;
-  font-src 'self';
-  connect-src 'self' https://analytics.domain.com;
-  frame-src https://www.google.com/recaptcha/;
-  object-src 'none';
-  base-uri 'self';
-  form-action 'self';
-  frame-ancestors 'none';
-  upgrade-insecure-requests;
-" always;
-```
-
----
-
-## 🚀 SECURITY IMPROVEMENTS ROADMAP
-
-### Immediate Implementation
-```bash
-# 1. Generate secure secrets
-openssl rand -base64 32 > jwt-secret.txt
-
-# 2. Update dependencies
-cd backend && npm install bcrypt@^6.0.0 helmet@^8.1.0
-cd ../frontend && npm update
-
-# 3. Add security scanning
-npm install -D npm-audit-resolver
-```
-
-### CI/CD Integration
-```yaml
-# Add to CI pipeline
-- name: Security Scan
-  run: |
-    npm audit --audit-level=moderate
-    npm run test:security
-```
-
-### Monitoring & Alerting
-1. Implement fail2ban for repeated auth failures
-2. Set up log analysis for suspicious patterns
-3. Configure alerts for security events
-4. Regular vulnerability scanning
-
----
-
-## 📋 COMPLIANCE CHECKLIST
-
-- [ ] OWASP Top 10 addressed
-- [ ] GDPR compliance (data minimization, right to erasure)
-- [ ] Security headers implemented
-- [ ] Dependency scanning automated
-- [ ] Incident response plan documented
-- [ ] Security documentation maintained
-- [ ] Regular security reviews scheduled
-
----
-
-## 🎯 CONCLUSION
-
-The wedding photo sharing application has a solid security foundation with excellent input validation and authentication mechanisms. However, operational security practices need immediate attention. The critical issues around secret management and token storage must be addressed before production deployment.
-
-Implementing the recommended fixes will raise the security score from 6.5/10 to approximately 8.5/10, providing a robust and secure platform for wedding photo sharing.
-
----
-
-*Generated by Claude Security Scanner v1.0*  
-*Next scan recommended: After Phase 1 remediation completion*

.drone.yml

@@ -72,6 +72,43 @@ steps:
       context: frontend/
       registry: registry.local.nothaft.cloud
 
+  # -------- NEW: Publish Docker images to GitHub Container Registry --------
+  - name: push-backend-ghcr
+    image: plugins/docker
+    settings:
+      repo: ghcr.io/the-luap/picpeak-backend
+      tags:
+        - ${DRONE_TAG}
+        - latest
+      dockerfile: backend/Dockerfile
+      context: backend/
+      registry: ghcr.io
+      username:
+        from_secret: GITHUB_USERNAME
+      password:
+        from_secret: GITHUB_TOKEN
+      build_args:
+        - VERSION=${DRONE_TAG}
+
+  - name: push-frontend-ghcr
+    image: plugins/docker
+    settings:
+      repo: ghcr.io/the-luap/picpeak-frontend
+      tags:
+        - ${DRONE_TAG}
+        - latest
+      dockerfile: frontend/Dockerfile
+      context: frontend/
+      registry: ghcr.io
+      username:
+        from_secret: GITHUB_USERNAME
+      password:
+        from_secret: GITHUB_TOKEN
+      build_args:
+        - VERSION=${DRONE_TAG}
+        - VITE_API_URL=${VITE_API_URL:-/api}
+
+
 trigger:
   event:
     - tag

.env.example

@@ -1,34 +1,71 @@
-# Environment Configuration Template
-# Copy this file to .env and adjust values for your environment
+# PicPeak Environment Configuration
+# Copy this file to .env and update with your values
 
-# Development: Use docker-compose.dev.yml
-# Production: Use docker-compose.prod.yml with .env.production.example
+# Environment
+NODE_ENV=production
 
-# JWT Secret (CRITICAL for production)
-# Generate with: openssl rand -base64 32
-JWT_SECRET=dev-secret-change-in-production
+# JWT Secret (generate with: openssl rand -base64 64)
+JWT_SECRET=your_very_long_random_jwt_secret_here
 
-# Application URLs
-ADMIN_URL=http://localhost:3005
-FRONTEND_URL=http://localhost:3005
+# Database Configuration (PostgreSQL)
+DATABASE_CLIENT=pg
+DB_USER=picpeak
+# IMPORTANT: Avoid $ character in passwords - Docker Compose interprets it as variable substitution
+# If you must use $, escape it as $$ (e.g., Pass$$word instead of Pass$word)
+DB_PASSWORD=your_secure_postgres_password_here
+DB_NAME=picpeak_prod
 
-# Database Configuration
-# SQLite is used for development by default
-# For production PostgreSQL config, see .env.production.example
-DATABASE_CLIENT=sqlite3
-DATABASE_PATH=./data/photo_sharing.db
+# Redis Configuration
+# IMPORTANT: Same warning applies - avoid $ or escape as $$
+REDIS_PASSWORD=your_secure_redis_password_here
+
+# Admin Account (initial setup)
+ADMIN_USERNAME=admin
+ADMIN_EMAIL=admin@yourdomain.com
 
 # Email Configuration
-# Development: Uses Mailhog (included in docker-compose.dev.yml)
-# Production: Configure real SMTP server
-SMTP_HOST=mailhog
-SMTP_PORT=1025
+# For Gmail: use app-specific password
+# For SendGrid: SMTP_USER=apikey, SMTP_PASS=your-api-key
+SMTP_HOST=smtp.gmail.com
+SMTP_PORT=587
 SMTP_SECURE=false
-SMTP_USER=
-SMTP_PASS=
-EMAIL_FROM=noreply@localhost
+SMTP_USER=your-email@gmail.com
+SMTP_PASS=your-app-specific-password
+EMAIL_FROM=noreply@yourdomain.com
 
-# Optional: Umami Analytics
-UMAMI_URL=
-UMAMI_WEBSITE_ID=
-UMAMI_HASH_SALT=
+# Application URLs
+# Use full origin with scheme, no trailing slash.
+# Admin UI is served by the frontend at /admin.
+FRONTEND_URL=https://yourdomain.com
+ADMIN_URL=https://yourdomain.com
+
+# Frontend API base
+# For pre-built images and production behind a reverse proxy, keep '/api'.
+# If you rebuild the frontend yourself, you may set a full URL at build time.
+VITE_API_URL=/api
+
+# Port Configuration (optional)
+# BACKEND_PORT=3001
+# FRONTEND_PORT=3000
+# DB_PORT=5432
+# REDIS_PORT=6379
+
+# Timezone
+TZ=UTC
+
+# Analytics (Optional - Umami)
+VITE_UMAMI_URL=
+VITE_UMAMI_WEBSITE_ID=
+VITE_UMAMI_SHARE_URL=
+
+# Storage variables (host paths)
+# These control where data is stored on the host. Defaults are local folders.
+APP_STORAGE=./storage
+APP_DATA=./data
+LOGS=./logs
+
+# Note on FRONTEND_API_URL (documentation only):
+# When using pre-built frontend images, runtime env vars cannot override the built JS.
+# Do NOT rely on FRONTEND_API_URL in Compose. Instead, keep VITE_API_URL=/api and
+# let the frontend Nginx proxy /api to the backend. Only if you rebuild the frontend
+# should you change VITE_API_URL at build time.

.env.production.example

@@ -1,44 +0,0 @@
-# PicPeak Production Configuration
-# Copy this file to .env and update with your values
-
-# Required: Security
-JWT_SECRET=CHANGE_THIS_TO_RANDOM_32_CHAR_STRING
-
-# Required: URLs (update with your domain)
-FRONTEND_URL=https://your-domain.com
-BACKEND_URL=https://your-domain.com
-ADMIN_URL=https://your-domain.com
-
-# Required: Email Settings
-SMTP_HOST=smtp.gmail.com
-SMTP_PORT=587
-SMTP_USER=your-email@gmail.com
-SMTP_PASS=your-app-password
-SMTP_FROM=your-email@gmail.com
-
-# Required: Initial Admin Account
-ADMIN_EMAIL=admin@your-domain.com
-ADMIN_PASSWORD=change-this-password
-
-# Database (PostgreSQL recommended for production)
-DATABASE_CLIENT=pg
-DB_HOST=postgres
-DB_PORT=5432
-DB_NAME=picpeak
-DB_USER=picpeak
-DB_PASSWORD=secure-database-password
-
-# Optional: Customization
-SITE_NAME=PicPeak
-DEFAULT_EXPIRATION_DAYS=30
-SESSION_TIMEOUT_MINUTES=60
-
-# Optional: Analytics (Umami)
-VITE_UMAMI_URL=
-VITE_UMAMI_WEBSITE_ID=
-
-# Advanced: Performance Tuning
-NODE_ENV=production
-BCRYPT_ROUNDS=12
-RATE_LIMIT_WINDOW_MS=900000
-RATE_LIMIT_MAX_REQUESTS=100

.gitattributes-github

@@ -1,12 +0,0 @@
-# Files to exclude from GitHub mirror
-.env* export-ignore
-docker-compose.prod.yml export-ignore
-.claudedocs/ export-ignore
-backend/data/ export-ignore
-backend/storage/ export-ignore
-backend/.env* export-ignore
-frontend/.env* export-ignore
-secrets/ export-ignore
-*.key export-ignore
-*.pem export-ignore
-.gitea/ export-ignore

.gitea/workflows/mirror-to-github.yml

@@ -9,59 +9,54 @@ on:
 jobs:
   mirror:
     runs-on: ubuntu-latest
+    # Note: For GitHub fine-grained tokens, ensure the token has:
+    # - Repository access to the-luap/picpeak
+    # - Repository permissions: Contents (Read and Write), Metadata (Read)
+    # For classic tokens: repo scope is sufficient
     steps:
       - name: Checkout repository
         uses: actions/checkout@v3
         with:
-          fetch-depth: 0  # Full history needed for mirroring
+          fetch-depth: 0  # Full history for proper mirroring
 
       - name: Setup Git
         run: |
           git config --global user.name "the-luap"
           git config --global user.email "paul-nothaft@hotmail.de"
 
-      - name: Debug - Show current branch and status
+      - name: Remove sensitive files and directories
         run: |
-          echo "Current branch:"
-          git branch -a
-          echo "Git status:"
-          git status
-          echo "Remote info:"
-          git remote -v
-
-      - name: Create filtered branch
-        run: |
-          # Clean up any existing github-mirror branch
-          git branch -D github-mirror || true
+          echo "Current files before cleanup:"
+          ls -la | head -10 || true
+          echo "..."
           
-          # Create a new branch for GitHub
-          git checkout --orphan github-mirror
-          
-          # Remove sensitive files/directories
-          # Example: Remove .env files, private configs, etc.
-          git rm -r --cached .env* || true
-          git rm -r --cached backend/.env* || true
-          git rm -r --cached frontend/.env* || true
-          git rm -r --cached docker-compose.prod.yml || true
-          git rm -r --cached .claudedocs/ || true
-          git rm -r --cached backend/data/ || true
-          git rm -r --cached backend/storage/ || true
-          git rm -r --cached .gitea/ || true
-          git rm -r --cached scripts/install-gitea-runner.sh || true
-          git rm -r --cached .drone* || true
-          git rm -r --cached .github-mirror-exclude || true
-          git rm -r --cached .gitattributes-github || true
-          git rm -r --cached photo-sharing-prd.md || true
-          git rm -r --cached CLAUDE.md || true
-          git rm -r --cached PRODUCTION_DEPLOYMENT_GUIDE.md || true
-          git rm -r --cached logs/ || true
-          git rm -r --cached frontend/.claudedocs/ || true
-          git rm -r --cached test-maintenance.sh || true
-          git rm -r --cached storage/ || true
+          # Remove sensitive files/directories if they exist
+          echo "Removing sensitive files..."
+          rm -rf .gitea/ || true
+          rm -rf scripts/install-gitea-runner.sh || true
+          rm -rf .drone* || true
+          rm -rf photo-sharing-prd.md || true
+          rm -rf CLAUDE.md || true
+          rm -rf storage/ || true
+          rm -rf events/ || true
+          rm -rf .playwright-mcp/
+          rm -rf .swarm || true
+          rm -rf .claude-flow || true
 
-        
-          # Commit the changes
-          git commit -m "Remove sensitive files for GitHub mirror" || true
+          
+          echo "Sensitive files removal completed"
+          
+          # Add and commit the cleanup if there are changes
+          git add -A
+          if ! git diff --cached --quiet; then
+            git commit -m "chore: remove sensitive files for GitHub mirror"
+            echo "✅ Committed cleanup of sensitive files"
+          else
+            echo "✅ No sensitive files to remove"
+          fi
+          
+          echo "Final file structure (top level):"
+          ls -la | head -10 || true
 
       - name: Check GitHub token
         env:
@@ -69,31 +64,71 @@ jobs:
         run: |
           if [ -z "$GITHUBTOKEN" ]; then
             echo "ERROR: GITHUBTOKEN secret is not set!"
+            echo "Please add a GitHub Personal Access Token as a secret named GITHUBTOKEN"
+            echo ""
+            echo "For fine-grained tokens:"
+            echo "  - Go to GitHub Settings > Developer settings > Personal access tokens > Fine-grained tokens"
+            echo "  - Create token with repository access to the-luap/picpeak"
+            echo "  - Grant permissions: Contents (Read and Write), Metadata (Read)"
+            echo ""
+            echo "For classic tokens:"
+            echo "  - Go to GitHub Settings > Developer settings > Personal access tokens > Tokens (classic)"
+            echo "  - Create token with 'repo' scope"
             exit 1
           else
-            echo "GitHub token is available (length: ${#GITHUBTOKEN})"
+            echo "✅ GitHub token is available (length: ${#GITHUBTOKEN})"
+            # Try to detect token type (fine-grained tokens are typically longer)
+            if [ ${#GITHUBTOKEN} -gt 80 ]; then
+              echo "📌 Token appears to be a fine-grained personal access token"
+            else
+              echo "📌 Token appears to be a classic personal access token"
+            fi
           fi
 
       - name: Push to GitHub
         env:
           GITHUBTOKEN: ${{ secrets.GITHUBTOKEN }}
+          GIT_TRACE: 1  # Enable Git trace for debugging if needed
         run: |
           # Remove existing github remote if it exists
           git remote remove github || true
           
-          # Add GitHub remote
-          git remote add github https://x-access-token:${GITHUBTOKEN}@github.com/the-luap/picpeak.git
+          # Configure Git to use the token for authentication
+          # This method works for both classic and fine-grained tokens
+          git config --global url."https://the-luap:${GITHUBTOKEN}@github.com/".insteadOf "https://github.com/"
+          
+          # Add GitHub remote (clean URL without credentials)
+          git remote add github https://github.com/the-luap/picpeak.git
           
           # Verify remote was added
-          echo "GitHub remote added:"
+          echo "GitHub remote configuration:"
           git remote -v
           
-          # Force push the filtered branch to GitHub main
+          # Push to GitHub main branch with error handling
           echo "Pushing to GitHub..."
-          git push github github-mirror:main --force
-          echo "Push completed successfully!"
+          if git push github main --force 2>&1; then
+            echo "✅ Push to GitHub completed successfully!"
+          else
+            echo "❌ Push to GitHub failed!"
+            echo ""
+            echo "Common issues and solutions:"
+            echo "1. Token permissions: Ensure your token has 'Contents: write' permission"
+            echo "2. Token expiration: Check if your token has expired"
+            echo "3. Repository access: Verify the token has access to the-luap/picpeak repository"
+            echo ""
+            echo "For fine-grained tokens, required permissions:"
+            echo "  - Repository access: the-luap/picpeak"
+            echo "  - Repository permissions: Contents (Read and Write), Metadata (Read)"
+            echo ""
+            echo "For classic tokens, required scope: 'repo'"
+            exit 1
+          fi
+          
+          # Clean up the git config after push
+          git config --global --unset url."https://the-luap:${GITHUBTOKEN}@github.com/".insteadOf
 
       - name: Workflow completed
         run: |
           echo "✅ Mirror to GitHub workflow completed successfully!"
-          echo "Check https://github.com/the-luap/picpeak to verify the mirror."
+          echo "📊 Repository mirrored to: https://github.com/the-luap/picpeak"
+          echo "🔒 Sensitive files have been removed from the mirror"

.gitea/workflows/version-and-release.yml

@@ -164,11 +164,25 @@ jobs:
       - name: Commit version bump
         if: steps.version.outputs.version_changed == 'true'
         run: |
+          set -e  # Exit on any error
+          
+          # First, ensure we have the latest changes
+          echo "Fetching latest changes..."
+          git fetch origin main
+          
+          # Check if we're behind and need to update
+          LOCAL=$(git rev-parse HEAD)
+          REMOTE=$(git rev-parse origin/main)
+          
+          if [ "$LOCAL" != "$REMOTE" ]; then
+            echo "Local is behind remote, pulling changes..."
+            git pull origin main --no-rebase
+          fi
+          
           COMPONENT="${{ steps.version.outputs.component_changed }}"
           
           if [ "$COMPONENT" = "both" ]; then
-            git add backend/package.json backend/package-lock.json
-            git add frontend/package.json frontend/package-lock.json
+            git add backend/package.json backend/package-lock.json frontend/package.json frontend/package-lock.json
             git commit -m "chore: bump version to ${{ steps.version.outputs.new_version }} (backend + frontend)"
           elif [ "$COMPONENT" = "backend" ]; then
             git add backend/package.json backend/package-lock.json
@@ -178,7 +192,51 @@ jobs:
             git commit -m "chore: bump frontend version to ${{ steps.version.outputs.new_version }}"
           fi
           
-          git push
+          # Pull latest changes before pushing to avoid conflicts
+          echo "Pulling latest changes from origin/main..."
+          if ! git pull --rebase origin main; then
+            echo "Rebase failed, attempting to resolve..."
+            # If rebase fails, abort and try a regular merge
+            git rebase --abort || true
+            git pull origin main --no-rebase
+          fi
+          
+          # Push the changes with retry logic
+          echo "Pushing version bump..."
+          PUSH_SUCCESS=false
+          
+          for i in 1 2 3; do
+            echo "Push attempt $i of 3..."
+            
+            # Try to push
+            if git push origin main 2>&1; then
+              echo "Successfully pushed version bump on attempt $i"
+              PUSH_SUCCESS=true
+              break
+            else
+              echo "Push failed on attempt $i"
+              
+              if [ $i -lt 3 ]; then
+                echo "Waiting 5 seconds before retry..."
+                sleep 5
+                
+                echo "Pulling latest changes..."
+                git fetch origin main
+                
+                # Try rebase first, fall back to merge
+                if ! git rebase origin/main; then
+                  echo "Rebase failed, trying merge..."
+                  git rebase --abort 2>/dev/null || true
+                  git pull origin main --no-rebase
+                fi
+              fi
+            fi
+          done
+          
+          if [ "$PUSH_SUCCESS" = "false" ]; then
+            echo "ERROR: Failed to push after 3 attempts"
+            exit 1
+          fi
       
       - name: Create Git tag
         if: steps.version.outputs.version_changed == 'true'

.github-mirror-exclude

@@ -1,24 +0,0 @@
-# Exclude patterns for GitHub mirror
-.env
-.env.*
-.env*
-docker-compose.prod.yml
-docker-compose.traefik.yml
-.claudedocs/
-backend/data/
-backend/storage/
-backend/.env*
-frontend/.env*
-secrets/
-*.key
-*.pem
-.gitea/
-node_modules/
-dist/
-build/
-*.log
-.DS_Store
-deploy/
-certbot/
-nginx/
-photo-sharing-prd.md

.github/workflows/README-DOCKER.md

@@ -0,0 +1,213 @@
+# Docker Build and Push Workflow
+
+This GitHub Actions workflow automatically builds and pushes Docker images for both the backend and frontend to GitHub Container Registry (ghcr.io).
+
+## Features
+
+- 🔧 **Automatic builds** on push to main/develop branches, PRs, and releases
+- 🏗️ **Multi-architecture support** (linux/amd64 and linux/arm64)
+- 🏷️ **Smart tagging** based on branches, versions, and commits
+- 🔒 **Security scanning** with Trivy vulnerability scanner
+- 💾 **Build caching** for faster subsequent builds
+- 📊 **Build summaries** in GitHub Actions UI
+
+## Authentication
+
+The workflow uses the built-in `GITHUB_TOKEN` for authentication with GitHub Container Registry. No additional setup or personal access tokens are required.
+
+### Required Permissions
+
+The workflow automatically sets the necessary permissions:
+- `contents: read` - To checkout the repository
+- `packages: write` - To push images to ghcr.io
+- `security-events: write` - To upload security scan results
+
+## Image Tags
+
+Images are automatically tagged based on the trigger event:
+
+| Event | Tags Generated |
+|-------|---------------|
+| Push to main | `latest`, `main`, `main-<short-sha>` |
+| Push to develop | `develop`, `develop-<short-sha>` |
+| Pull Request | `pr-<number>` |
+| Release (v1.2.3) | `1.2.3`, `1.2`, `1`, `latest` |
+| Manual trigger | Based on branch + optional push |
+
+## Usage
+
+### Pull Images
+
+Once published, images can be pulled using:
+
+```bash
+# Pull backend image
+docker pull ghcr.io/the-luap/picpeak/backend:latest
+
+# Pull frontend image
+docker pull ghcr.io/the-luap/picpeak/frontend:latest
+
+# Pull specific version
+docker pull ghcr.io/the-luap/picpeak/backend:v1.0.0
+
+# Pull for specific architecture
+docker pull --platform linux/arm64 ghcr.io/the-luap/picpeak/backend:latest
+```
+
+### Using in Docker Compose
+
+```yaml
+version: '3.8'
+
+services:
+  backend:
+    image: ghcr.io/the-luap/picpeak/backend:latest
+    environment:
+      - NODE_ENV=production
+    ports:
+      - "3001:3000"
+
+  frontend:
+    image: ghcr.io/the-luap/picpeak/frontend:latest
+    ports:
+      - "80:80"
+```
+
+### Using in Kubernetes
+
+```yaml
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: picpeak-backend
+spec:
+  replicas: 3
+  template:
+    spec:
+      containers:
+      - name: backend
+        image: ghcr.io/the-luap/picpeak/backend:latest
+        imagePullPolicy: Always
+```
+
+## Manual Workflow Trigger
+
+You can manually trigger the workflow from the Actions tab:
+
+1. Go to Actions → "Build and Push Docker Images"
+2. Click "Run workflow"
+3. Select branch and whether to push images
+4. Click "Run workflow"
+
+## Security Scanning
+
+The workflow includes Trivy vulnerability scanning that:
+- Scans for CRITICAL and HIGH severity vulnerabilities
+- Uploads results to GitHub Security tab
+- Available under Security → Code scanning alerts
+
+## Build Optimization
+
+The workflow uses several optimization techniques:
+
+1. **GitHub Actions Cache**: Speeds up builds by caching layers
+2. **Multi-stage builds**: Reduces final image size
+3. **Parallel builds**: Backend and frontend build simultaneously
+4. **Smart rebuilds**: Only rebuilds changed components
+
+## Troubleshooting
+
+### Permission Denied Errors
+
+If you encounter permission errors when pushing images:
+
+1. **First-time setup**: The first push creates a private package. You may need to:
+   - Go to your package settings at `https://github.com/users/YOUR_USERNAME/packages`
+   - Link the package to your repository
+   - Set package visibility (public/private)
+
+2. **Organization repositories**: Ensure the organization allows GitHub Actions to create packages
+
+### Build Failures
+
+Check the workflow logs in the Actions tab for detailed error messages. Common issues:
+- Missing dependencies in package.json
+- Dockerfile syntax errors
+- Network issues during package installation
+
+### Image Not Found
+
+If images aren't visible after successful push:
+- Check package visibility settings
+- Ensure you're authenticated to pull private images:
+  ```bash
+  echo $GITHUB_TOKEN | docker login ghcr.io -u YOUR_USERNAME --password-stdin
+  ```
+
+## Package Management
+
+### View Packages
+
+Your Docker images are available at:
+- Backend: `https://github.com/users/the-luap/packages/container/package/picpeak%2Fbackend`
+- Frontend: `https://github.com/users/the-luap/packages/container/package/picpeak%2Ffrontend`
+
+### Delete Old Versions
+
+To save storage, you can delete old versions:
+1. Go to package settings
+2. Click on "Manage versions"
+3. Select versions to delete
+4. Click "Delete selected versions"
+
+### Set Retention Policy
+
+Configure automatic cleanup in package settings:
+1. Go to package settings
+2. Click on "Manage Actions access"
+3. Set retention days for untagged versions
+
+## Best Practices
+
+1. **Use semantic versioning** for releases (e.g., v1.2.3)
+2. **Test images locally** before pushing to production
+3. **Monitor security alerts** from Trivy scans
+4. **Clean up old images** regularly to save storage
+5. **Use specific tags** in production (avoid `latest`)
+
+## Advanced Configuration
+
+### Custom Registry
+
+To use a different registry, update the workflow:
+
+```yaml
+env:
+  REGISTRY: docker.io  # or your custom registry
+  BACKEND_IMAGE_NAME: yourusername/picpeak-backend
+```
+
+### Additional Platforms
+
+To build for more platforms:
+
+```yaml
+platforms: linux/amd64,linux/arm64,linux/arm/v7
+```
+
+### Custom Build Arguments
+
+Add build arguments in the workflow:
+
+```yaml
+build-args: |
+  NODE_VERSION=20
+  API_URL=${{ secrets.API_URL }}
+```
+
+## Related Documentation
+
+- [GitHub Container Registry Docs](https://docs.github.com/en/packages/working-with-a-github-packages-registry/working-with-the-container-registry)
+- [Docker Build Action](https://github.com/docker/build-push-action)
+- [Trivy Security Scanner](https://github.com/aquasecurity/trivy)
+- [Multi-platform Builds](https://docs.docker.com/build/building/multi-platform/)

.github/workflows/docker-build.yml

@@ -0,0 +1,223 @@
+name: Build and Push Docker Images
+
+on:
+  push:
+    branches: [ main, develop ]
+    tags: [ 'v*.*.*' ]
+  pull_request:
+    branches: [ main ]
+  release:
+    types: [ published ]
+  workflow_dispatch:
+    inputs:
+      push:
+        description: 'Push images to registry'
+        required: false
+        default: 'false'
+        type: choice
+        options:
+          - 'true'
+          - 'false'
+
+env:
+  REGISTRY: ghcr.io
+  BACKEND_IMAGE_NAME: ${{ github.repository }}/backend
+  FRONTEND_IMAGE_NAME: ${{ github.repository }}/frontend
+
+jobs:
+  build-backend:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+      security-events: write
+    
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v3
+      with:
+        platforms: linux/amd64,linux/arm64
+
+    - name: Log in to Container Registry
+      if: github.event_name != 'pull_request' || github.event.inputs.push == 'true'
+      uses: docker/login-action@v3
+      with:
+        registry: ${{ env.REGISTRY }}
+        username: ${{ github.actor }}
+        password: ${{ secrets.GITHUB_TOKEN }}
+
+    - name: Extract metadata for Backend
+      id: meta-backend
+      uses: docker/metadata-action@v5
+      with:
+        images: ${{ env.REGISTRY }}/${{ env.BACKEND_IMAGE_NAME }}
+        labels: |
+          org.opencontainers.image.title=PicPeak Backend
+          org.opencontainers.image.description=PicPeak photo sharing platform backend service
+          org.opencontainers.image.vendor=PicPeak
+          maintainer=${{ github.repository_owner }}
+        tags: |
+          type=ref,event=branch
+          type=ref,event=pr
+          type=semver,pattern={{version}}
+          type=semver,pattern={{major}}.{{minor}}
+          type=semver,pattern={{major}}
+          type=sha,prefix={{branch}}-,format=short
+          type=raw,value=latest,enable={{is_default_branch}}
+
+    - name: Build and push Backend Docker image
+      uses: docker/build-push-action@v5
+      with:
+        context: ./backend
+        file: ./backend/Dockerfile
+        push: ${{ github.event_name != 'pull_request' || github.event.inputs.push == 'true' }}
+        tags: ${{ steps.meta-backend.outputs.tags }}
+        labels: ${{ steps.meta-backend.outputs.labels }}
+        platforms: linux/amd64,linux/arm64
+        cache-from: type=gha,scope=backend
+        cache-to: type=gha,mode=max,scope=backend
+        build-args: |
+          CACHEBUST=${{ github.run_number }}
+          BUILD_DATE=${{ github.event.head_commit.timestamp }}
+          VCS_REF=${{ github.sha }}
+          VERSION=${{ steps.meta-backend.outputs.version }}
+
+    - name: Run Trivy vulnerability scanner
+      if: github.event_name != 'pull_request'
+      uses: aquasecurity/trivy-action@master
+      with:
+        image-ref: ${{ env.REGISTRY }}/${{ env.BACKEND_IMAGE_NAME }}:${{ steps.meta-backend.outputs.version }}
+        format: 'sarif'
+        output: 'trivy-backend.sarif'
+        severity: 'CRITICAL,HIGH'
+        timeout: '10m'
+
+    - name: Upload Trivy scan results to GitHub Security tab
+      if: github.event_name != 'pull_request'
+      uses: github/codeql-action/upload-sarif@v3
+      with:
+        sarif_file: 'trivy-backend.sarif'
+        category: 'backend-vulnerabilities'
+
+  build-frontend:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+      security-events: write
+    
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v3
+      with:
+        platforms: linux/amd64,linux/arm64
+
+    - name: Log in to Container Registry
+      if: github.event_name != 'pull_request' || github.event.inputs.push == 'true'
+      uses: docker/login-action@v3
+      with:
+        registry: ${{ env.REGISTRY }}
+        username: ${{ github.actor }}
+        password: ${{ secrets.GITHUB_TOKEN }}
+
+    - name: Extract metadata for Frontend
+      id: meta-frontend
+      uses: docker/metadata-action@v5
+      with:
+        images: ${{ env.REGISTRY }}/${{ env.FRONTEND_IMAGE_NAME }}
+        labels: |
+          org.opencontainers.image.title=PicPeak Frontend
+          org.opencontainers.image.description=PicPeak photo sharing platform frontend application
+          org.opencontainers.image.vendor=PicPeak
+          maintainer=${{ github.repository_owner }}
+        tags: |
+          type=ref,event=branch
+          type=ref,event=pr
+          type=semver,pattern={{version}}
+          type=semver,pattern={{major}}.{{minor}}
+          type=semver,pattern={{major}}
+          type=sha,prefix={{branch}}-,format=short
+          type=raw,value=latest,enable={{is_default_branch}}
+
+    - name: Build and push Frontend Docker image
+      uses: docker/build-push-action@v5
+      with:
+        context: ./frontend
+        file: ./frontend/Dockerfile
+        push: ${{ github.event_name != 'pull_request' || github.event.inputs.push == 'true' }}
+        tags: ${{ steps.meta-frontend.outputs.tags }}
+        labels: ${{ steps.meta-frontend.outputs.labels }}
+        platforms: linux/amd64,linux/arm64
+        cache-from: type=gha,scope=frontend
+        cache-to: type=gha,mode=max,scope=frontend
+        build-args: |
+          CACHEBUST=${{ github.run_number }}
+          BUILD_DATE=${{ github.event.head_commit.timestamp }}
+          VCS_REF=${{ github.sha }}
+          VERSION=${{ steps.meta-frontend.outputs.version }}
+
+    - name: Run Trivy vulnerability scanner
+      if: github.event_name != 'pull_request'
+      uses: aquasecurity/trivy-action@master
+      with:
+        image-ref: ${{ env.REGISTRY }}/${{ env.FRONTEND_IMAGE_NAME }}:${{ steps.meta-frontend.outputs.version }}
+        format: 'sarif'
+        output: 'trivy-frontend.sarif'
+        severity: 'CRITICAL,HIGH'
+        timeout: '10m'
+
+    - name: Upload Trivy scan results to GitHub Security tab
+      if: github.event_name != 'pull_request'
+      uses: github/codeql-action/upload-sarif@v3
+      with:
+        sarif_file: 'trivy-frontend.sarif'
+        category: 'frontend-vulnerabilities'
+
+  # Note: The publish-manifest job is not needed since docker/build-push-action@v5
+  # automatically creates multi-arch manifests when building for multiple platforms.
+  # The images are already properly tagged and include all architectures.
+
+  summary:
+    needs: [build-backend, build-frontend]
+    if: always()
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    
+    steps:
+    - name: Build Summary
+      run: |
+        echo "## 🐳 Docker Build Summary" >> $GITHUB_STEP_SUMMARY
+        echo "" >> $GITHUB_STEP_SUMMARY
+        
+        if [[ "${{ needs.build-backend.result }}" == "success" ]]; then
+          echo "✅ **Backend**: Successfully built" >> $GITHUB_STEP_SUMMARY
+        else
+          echo "❌ **Backend**: Build failed" >> $GITHUB_STEP_SUMMARY
+        fi
+        
+        if [[ "${{ needs.build-frontend.result }}" == "success" ]]; then
+          echo "✅ **Frontend**: Successfully built" >> $GITHUB_STEP_SUMMARY
+        else
+          echo "❌ **Frontend**: Build failed" >> $GITHUB_STEP_SUMMARY
+        fi
+        
+        echo "" >> $GITHUB_STEP_SUMMARY
+        echo "### 📦 Images" >> $GITHUB_STEP_SUMMARY
+        echo "- Backend: \`${{ env.REGISTRY }}/${{ env.BACKEND_IMAGE_NAME }}\`" >> $GITHUB_STEP_SUMMARY
+        echo "- Frontend: \`${{ env.REGISTRY }}/${{ env.FRONTEND_IMAGE_NAME }}\`" >> $GITHUB_STEP_SUMMARY
+        
+        echo "" >> $GITHUB_STEP_SUMMARY
+        echo "### 🏷️ Tags" >> $GITHUB_STEP_SUMMARY
+        echo "Images are tagged based on:" >> $GITHUB_STEP_SUMMARY
+        echo "- Branch name (for branch pushes)" >> $GITHUB_STEP_SUMMARY
+        echo "- PR number (for pull requests)" >> $GITHUB_STEP_SUMMARY
+        echo "- Version tags (for releases)" >> $GITHUB_STEP_SUMMARY
+        echo "- Short SHA with branch prefix" >> $GITHUB_STEP_SUMMARY
+        echo "- \`latest\` (for main branch)" >> $GITHUB_STEP_SUMMARY

.gitignore

@@ -11,6 +11,9 @@ yarn-error.log*
 .env.test.local
 .env.production.local
 
+# Docker override file
+docker-compose.override.yml
+
 # Security - Never commit credentials
 ADMIN_CREDENTIALS.txt
 ADMIN_PASSWORD_RESET.txt
@@ -48,9 +51,33 @@ coverage/
 *.tmp
 *.temp
 
+# Backup and test directories
+backups/
+test-archiver/
+
 # Keep directory structure
 !storage/events/active/.gitkeep
 !storage/events/archived/.gitkeep
 !storage/thumbnails/.gitkeep
 !data/.gitkeep
 !logs/.gitkeep
+
+# development files
+backend/.swarm/
+.claudedocs/
+backend/data/
+backend/docs/
+backend/logs/
+logs/
+storage/
+data/
+certbot/
+
+# Ignore local contributor guide copy
+AGENTS.md
+
+# Local artifacts from browser tooling
+.playwright-mcp/
+
+# Local SQLite files in backend
+backend/*.sqlite*

CLAUDE.md

@@ -33,11 +33,20 @@ npm test -- path/to/test.test.js
 npm test -- --testNamePattern="test name"
 ```
 
-### Production
-```bash
-docker-compose -f docker-compose.prod.yml up -d  # Production deployment
-pm2 start ecosystem.config.js                     # Alternative: PM2 deployment
-```
+### Production Deployment
+See [DEPLOYMENT_GUIDE.md](./DEPLOYMENT_GUIDE.md) for comprehensive deployment instructions including:
+- Docker Compose deployment
+- PM2 deployment
+- Manual installation
+- Non-nginx deployment options
+- SSL/HTTPS setup
+- Troubleshooting guide
+
+**⚠️ CRITICAL PRODUCTION NOTICE:**
+- Production runs on a SEPARATE SERVER - never assume local changes affect production
+- ALWAYS request production server details before any troubleshooting
+- NO trial-and-error approaches in production - data loss is unacceptable
+- Every change must be thoroughly analyzed and tested locally first
 
 ## Key Product Requirements (from PRD)
 
@@ -111,6 +120,7 @@ Background services run as separate processes:
 - **archiveService**: Creates ZIP archives of expired events
 - **expirationChecker**: Cron job for expiration warnings
 - **fileWatcher**: Monitors for new photo uploads
+- **backupService**: Scheduled backups with checksum-based change detection
 
 ### API Structure
 - `/api/admin/*` - Admin panel endpoints (requires adminAuth)
@@ -127,6 +137,41 @@ Background services run as separate processes:
 5. **Frontend Status**: Only skeleton exists - requires full implementation based on PRD
 6. **Umami Analytics**: Track password entries, downloads, views, expiration warnings
 
+## Troubleshooting Guidelines
+
+### Before ANY Production Troubleshooting:
+1. **ALWAYS request specific details**:
+   - Production server URL/IP
+   - Current error messages/logs
+   - Recent changes or deployments
+   - Affected users/galleries
+   - Time of issue occurrence
+
+2. **Thorough Analysis Required**:
+   - Use detailed thinking/analysis for EVERY troubleshooting task
+   - Review all related code before suggesting changes
+   - Consider all potential side effects
+   - Never make assumptions about production environment
+
+3. **Safe Troubleshooting Steps**:
+   - First, reproduce issue in local/dev environment
+   - Analyze logs without modifying production
+   - Create detailed action plan before any changes
+   - Always have rollback strategy ready
+   - Document every step taken
+
+### Common Issues & Safe Approaches:
+- **Email not sending**: Check email_queue table, SMTP settings, service status
+- **Photos not loading**: Verify file permissions, storage paths, nginx config
+- **Gallery access issues**: Check JWT tokens, expiration dates, access_logs
+- **Performance problems**: Analyze with monitoring tools first, never experiment
+
+### Data Safety Rules:
+- NEVER delete or modify production data without explicit backup confirmation
+- ALWAYS verify backups exist before any data operations
+- NO direct database modifications without transaction safety
+- Log all actions for audit trail
+
 ## Environment Variables
 
 ### Backend (.env)
@@ -253,9 +298,89 @@ const { theme, setTheme, setThemeByName } = useTheme();
 --border-radius: 0.5rem;
 ```
 
+## Backup Service
+
+### Overview
+The backup service provides automated, scheduled backups of all photo data with checksum-based change detection to minimize transfer overhead.
+
+### Features
+- **Multiple Destinations**: Local directory, remote server (rsync), S3-compatible storage
+- **Change Detection**: SHA256 checksums track file changes, only modified files are backed up
+- **Scheduled Execution**: Configurable cron-based scheduling (default: 2 AM daily)
+- **Email Notifications**: Alerts on backup failure, optional success notifications
+- **Retention Management**: Automatic cleanup of old backup runs based on retention policy
+- **Progress Tracking**: Database storage of backup history, file states, and statistics
+
+### Configuration
+Backup settings are stored in `app_settings` table with `backup_` prefix:
+- `backup_enabled`: Enable/disable the service
+- `backup_schedule`: Cron expression (e.g., '0 2 * * *')
+- `backup_destination_type`: 'local', 'rsync', or 's3'
+- `backup_retention_days`: How long to keep backup history
+- `backup_include_archived`: Whether to backup archived events
+- `backup_exclude_patterns`: File patterns to exclude
+
+### API Endpoints
+- `GET /api/admin/backup/config` - Get current configuration
+- `PUT /api/admin/backup/config` - Update configuration
+- `GET /api/admin/backup/status` - Get backup status and history
+- `POST /api/admin/backup/run` - Trigger manual backup
+- `POST /api/admin/backup/test-connection` - Test destination connectivity
+
+### Testing
+Run backup service test: `npm run test-backup`
+
+### Database Tables
+- `backup_runs`: Tracks each backup execution with statistics
+- `backup_file_states`: Stores file checksums for change detection
+
+## Thumbnail Generation
+
+### Square Thumbnail Implementation (Issue #12 Fix)
+The system now generates **square 300x300px thumbnails** to prevent blurry/stretched images in the gallery grid:
+
+- **Problem**: Previously generated 300px width with proportional height (e.g., 300x200 for 3:2 photos), but CSS forced square display causing distortion
+- **Solution**: Thumbnails now use `cover` fit mode to crop to exact 300x300px dimensions with center positioning
+- **Configuration**: Settings stored in `app_settings` table with keys: `thumbnail_width`, `thumbnail_height`, `thumbnail_fit`, `thumbnail_quality`, `thumbnail_format`
+- **Migration**: Run `040_add_thumbnail_settings.js` to add default square thumbnail settings
+- **Regeneration Script**: Use `scripts/regenerate-square-thumbnails.js` to update existing thumbnails
+
+### Thumbnail Settings API
+- `GET /api/admin/thumbnails/settings` - Get current thumbnail configuration
+- `PUT /api/admin/thumbnails/settings` - Update thumbnail settings (requires regeneration)
+- `POST /api/admin/thumbnails/regenerate` - Regenerate all thumbnails with new settings
+- `GET /api/admin/thumbnails/regenerate/status` - Check regeneration progress
+
 ## Success Metrics (from PRD)
 - Time to generate gallery: <2 minutes
 - Guest satisfaction: >90%
 - System uptime: 99.9%
 - Email delivery rate: >98%
-- Successful archiving: 100%
+- Successful archiving: 100%
+
+## Documentation & Development Practices
+
+### Documentation Guidelines:
+- **NEVER create new documentation files for simple tasks**
+- **ALWAYS update existing documentation (like this CLAUDE.md)**
+- Only create new .md files when explicitly requested
+- Avoid creating temporary scripts for one-off tasks
+
+### Development Best Practices:
+- Test all changes thoroughly in local environment first
+- Use version control for all changes
+- Keep commits atomic and well-described
+- Review impact on all integrated services
+- Consider backward compatibility
+- Update tests when changing functionality
+
+### Production Deployment Checklist:
+- [ ] All tests passing locally
+- [ ] Linting and type checks pass
+- [ ] Database migrations tested with rollback plan
+- [ ] Environment variables documented
+- [ ] Backup strategy confirmed
+- [ ] Monitoring alerts configured
+- [ ] Rollback procedure documented
+- [ ] Stakeholders notified of maintenance window
+- always use docker deployment for testing

CODE_OF_CONDUCT.md

@@ -20,7 +20,7 @@ We are committed to providing a welcoming and inspiring community for all photog
 
 ## Enforcement
 
-Instances of unacceptable behavior may be reported to the project team at conduct@example.com. All complaints will be reviewed and investigated promptly and fairly.
+Instances of unacceptable behavior may be reported by [opening an issue](https://github.com/the-luap/picpeak/issues/new?labels=conduct) on GitHub. All complaints will be reviewed and investigated promptly and fairly.
 
 ## Attribution
 

CONTRIBUTING.md

@@ -153,8 +153,8 @@ picpeak/
 
 ## 📮 Contact
 
-- Create an issue for bugs or features
-- Join discussions for questions
-- Email: picpeak@example.com for security issues
+- Create an [issue](https://github.com/the-luap/picpeak/issues) for bugs or features
+- Join [discussions](https://github.com/the-luap/picpeak/discussions) for questions
+- Security issues: Open a [security issue](https://github.com/the-luap/picpeak/issues/new?labels=security) on GitHub
 
 Thank you for contributing! 🎉

DEPLOYMENT.md

@@ -1,220 +0,0 @@
-# 🚀 PicPeak Deployment Guide
-
-This guide will help you deploy PicPeak in production. The entire process takes about 10-15 minutes.
-
-## 📋 Prerequisites
-
-- A server with Docker and Docker Compose installed
-- A domain name (for SSL certificates)
-- SMTP credentials for sending emails
-- Basic command line knowledge
-
-## 🏃 Quick Deploy (Recommended)
-
-### 1. Clone and Configure
-
-```bash
-# Clone the repository
-git clone https://github.com/the-luap/picpeak.git
-cd picpeak
-
-# Copy environment template
-cp .env.production.example .env
-
-# Generate a secure JWT secret
-echo "JWT_SECRET=$(openssl rand -base64 32)" >> .env
-
-# Edit configuration
-nano .env
-```
-
-### 2. Required Environment Variables
-
-Edit your `.env` file with these essential settings:
-
-```env
-# Application URLs
-FRONTEND_URL=https://your-domain.com
-BACKEND_URL=https://your-domain.com
-
-# Email Configuration (Required for notifications)
-SMTP_HOST=smtp.gmail.com
-SMTP_PORT=587
-SMTP_USER=your-email@gmail.com
-SMTP_PASS=your-app-password
-SMTP_FROM=your-email@gmail.com
-
-# Admin Configuration
-ADMIN_EMAIL=admin@your-domain.com
-ADMIN_PASSWORD=your-secure-password
-
-# Database (PostgreSQL for production)
-DATABASE_CLIENT=pg
-DB_HOST=postgres
-DB_NAME=picpeak
-DB_USER=picpeak
-DB_PASSWORD=secure-db-password
-```
-
-### 3. Deploy with Docker Compose
-
-```bash
-# Start all services
-docker-compose -f docker-compose.prod.yml up -d
-
-# Check logs
-docker-compose logs -f
-
-# Access your site at https://your-domain.com
-```
-
-## 🔧 Configuration Options
-
-### Storage Settings
-
-```env
-# Storage paths (default: ./storage)
-STORAGE_PATH=./storage
-ARCHIVE_PATH=./storage/archives
-
-# Gallery expiration (days)
-DEFAULT_EXPIRATION_DAYS=30
-WARNING_DAYS_BEFORE_EXPIRY=7
-```
-
-### Security Settings
-
-```env
-# Session timeout (minutes)
-SESSION_TIMEOUT=60
-
-# Rate limiting
-RATE_LIMIT_WINDOW_MS=900000  # 15 minutes
-RATE_LIMIT_MAX_REQUESTS=100
-```
-
-### Analytics (Optional)
-
-```env
-# Umami Analytics
-VITE_UMAMI_URL=https://analytics.your-domain.com
-VITE_UMAMI_WEBSITE_ID=your-website-id
-```
-
-## 🔒 SSL/TLS Setup
-
-The production Docker Compose includes automatic SSL via Let's Encrypt:
-
-1. **Ensure your domain points to your server**
-2. **Update nginx configuration**:
-   ```bash
-   nano nginx/nginx.conf
-   # Replace your-domain.com with your actual domain
-   ```
-3. **Start services** - Certbot will automatically obtain certificates
-
-## 📁 Directory Structure
-
-After deployment, your directory structure will be:
-
-```
-picpeak/
-├── backend/          # API server
-├── frontend/         # React app
-├── storage/          # Photo storage
-│   ├── events/       # Active galleries
-│   │   ├── active/   # Current photos
-│   │   └── archived/ # Expired galleries
-│   ├── thumbnails/   # Generated thumbnails
-│   └── uploads/      # User uploads
-├── data/            # Database files
-└── logs/            # Application logs
-```
-
-## 🔄 Maintenance
-
-### Backup
-
-```bash
-# Backup database and photos
-./scripts/backup.sh
-
-# Backups are stored in ./backups/
-```
-
-### Update
-
-```bash
-# Pull latest changes
-git pull
-
-# Rebuild and restart
-docker-compose -f docker-compose.prod.yml up -d --build
-```
-
-### Logs
-
-```bash
-# View all logs
-docker-compose logs
-
-# View specific service
-docker-compose logs backend
-docker-compose logs frontend
-```
-
-## 🚨 Troubleshooting
-
-### Common Issues
-
-**Photos not appearing:**
-- Check storage permissions: `chmod -R 755 storage/`
-- Verify file watcher is running: `docker-compose logs backend | grep watcher`
-
-**Email not sending:**
-- Test SMTP settings: Admin Panel → Settings → Email → Send Test
-- Check email queue: Admin Panel → System → Email Queue
-
-**Can't access admin panel:**
-- Default login: Use email/password from `.env`
-- Reset password: `docker exec picpeak-backend npm run reset-admin`
-
-### Health Check
-
-```bash
-# Check service status
-docker-compose ps
-
-# Test backend API
-curl https://your-domain.com/api/health
-
-# Check disk space
-df -h storage/
-```
-
-## 🐳 Alternative Deployment Methods
-
-### Using Docker Swarm
-
-For high availability deployments, see [Docker Swarm Setup](deploy/README.md).
-
-### Manual Installation
-
-If you prefer not to use Docker:
-
-1. Install Node.js 18+
-2. Install PostgreSQL
-3. Clone repository
-4. Install dependencies: `npm install` in both `/backend` and `/frontend`
-5. Build frontend: `cd frontend && npm run build`
-6. Start services with PM2
-
-## 📞 Support
-
-- 📘 [Documentation](https://github.com/the-luap/picpeak)
-- 🐛 [Report Issues](https://github.com/the-luap/picpeak/issues)
-- 💬 [Discussions](https://github.com/the-luap/picpeak/discussions)
-
----
-
-**Need help?** Open an issue on GitHub and we'll assist you!

DEPLOYMENT_GUIDE.md

@@ -0,0 +1,800 @@
+# 🚀 PicPeak Deployment Guide
+
+This guide covers multiple deployment options for PicPeak, from simple local setups to production-ready configurations.
+
+## 🎯 Quick Start - Simple Setup (Recommended for Beginners)
+
+For the easiest installation without Docker or complex configurations, use our **unified setup script**:
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/the-luap/picpeak/main/scripts/setup.sh -o setup.sh && \
+chmod +x setup.sh && \
+sudo ./setup.sh
+```
+
+This automated script handles everything including:
+- Choice between Docker or Native installation
+- OS detection and dependency installation
+- Database setup and service configuration
+- SSL/HTTPS setup (optional)
+
+Perfect for:
+- Small to medium deployments
+- Local or VPS installations  
+- Users new to server management
+- Quick testing and evaluation
+
+👉 **See [SIMPLE_SETUP.md](./SIMPLE_SETUP.md) for detailed instructions.**
+
+---
+
+## 🐳 Docker Compose Deployment
+
+### Option 1: Using Pre-built Images (Recommended)
+
+PicPeak provides official Docker images via GitHub Container Registry for quick deployment without building:
+
+```bash
+# Clone repository for configuration files
+git clone https://github.com/the-luap/picpeak.git
+cd picpeak
+
+# Copy and configure environment
+cp .env.example .env
+nano .env  # Edit with your values
+
+# Use pre-built images deployment
+docker compose -f docker-compose.production.yml up -d
+```
+
+The production compose file uses:
+- **Backend**: `ghcr.io/the-luap/picpeak/backend:latest`
+- **Frontend**: `ghcr.io/the-luap/picpeak/frontend:latest`
+
+Available tags:
+- `latest` - Latest stable release
+- `main` - Latest main branch build
+- `develop` - Development branch (may be unstable)
+- `v1.0.0` - Specific version tags
+
+### Option 2: Building from Source
+
+If you need to customize the application or the pre-built images aren't available, you can build locally:
+
+## 📋 Table of Contents
+
+- [Prerequisites](#prerequisites)
+- [Quick Start](#quick-start)
+- [Configuration](#configuration)
+- [Deployment](#deployment)
+- [First Login](#first-login)
+- [Reverse Proxy Setup](#reverse-proxy-setup)
+- [Maintenance](#maintenance)
+- [Troubleshooting](#troubleshooting)
+ - [External Media Library](#external-media-library)
+
+## Prerequisites
+
+- Docker and Docker Compose installed
+- Domain name (for production)
+- SMTP server credentials for emails
+- At least 2GB RAM and 20GB storage
+
+## 🚀 Quick Start
+
+### Method 1: Using Pre-built Images (Fastest)
+
+1. **Clone the repository for configs**
+   ```bash
+   git clone https://github.com/the-luap/picpeak.git
+   cd picpeak
+   ```
+
+2. **Set up environment**
+   ```bash
+   cp .env.example .env
+   nano .env  # Edit with your values
+   ```
+
+3. **Create required directories**
+   ```bash
+   mkdir -p events/active events/archived data logs backup storage
+   chmod -R 755 events data logs backup storage
+   ```
+
+4. **Deploy using pre-built images**
+   ```bash
+   docker compose -f docker-compose.production.yml up -d
+   ```
+
+5. **Check logs**
+   ```bash
+   docker compose -f docker-compose.production.yml logs -f
+   ```
+
+## External Media Library
+
+PicPeak can reference an existing, read‑only media library mounted into the backend container. This avoids copying originals into PicPeak storage.
+
+- Map your host library path to the container as read‑only in `docker-compose.production.yml`:
+  - Add volume under `backend`: `- ${EXTERNAL_MEDIA}:/external-media:ro`
+  - Add backend env: `EXTERNAL_MEDIA_ROOT=/external-media`
+- In `.env`, set:
+  - `EXTERNAL_MEDIA=/mnt/photos` (example host path)
+  - `EXTERNAL_MEDIA_ROOT=/external-media`
+
+Usage:
+- In Admin → Events, set “Source Mode” to “Reference (external folder)”, select a folder under `/external-media`, then import to index and generate thumbnails. Originals stay in your library.
+
+Backups and Archives:
+- Backups only include data under `STORAGE_PATH` and exclude external originals. The backup manifest includes `metadata.external_references = { excluded: true, events: N, photos: M }` and the Admin UI surfaces a warning.
+- Archiving reference events creates a manifest‑only ZIP and deletes thumbnails for that event. External originals are never moved or deleted.
+
+Local (npm) setup (no Docker):
+
+1. Create or choose a folder that contains your external originals, e.g. `/Users/you/Pictures/picpeak-external` (macOS/Linux) or `C:\\Pictures\\picpeak-external` (Windows).
+2. In `backend/.env` (or your shell), set:
+   - `EXTERNAL_MEDIA_ROOT=/absolute/path/to/picpeak-external`
+   - Ensure `STORAGE_PATH` points to your PicPeak storage (defaults to `./storage`).
+3. Start services from source:
+   - Backend: `cd backend && npm install && npm run migrate && JWT_SECRET=... npm start`
+   - Frontend: `cd frontend && npm install && npm run dev` (or build + serve)
+4. In Admin → Events:
+   - Create an event, set “Source Mode” to “Reference (external folder)”.
+   - Use the folder picker to browse under your `EXTERNAL_MEDIA_ROOT` and select the subfolder to reference.
+   - Click “Import from selected folder” to index files and generate thumbnails on demand.
+
+Notes:
+- PicPeak only reads from `EXTERNAL_MEDIA_ROOT`; it never modifies or deletes your originals there.
+- Thumbnails are generated under `STORAGE_PATH/thumbnails` and are included in backups; originals in `EXTERNAL_MEDIA_ROOT` are excluded.
+- On Windows, use absolute paths (e.g., `C:\\Photos\\Library`) for `EXTERNAL_MEDIA_ROOT`.
+
+### Method 2: Building from Source
+
+1. **Clone the repository**
+   ```bash
+   git clone https://github.com/the-luap/picpeak.git
+   cd picpeak
+   ```
+
+2. **Set up environment**
+   ```bash
+   cp .env.example .env
+   nano .env  # Edit with your values
+   ```
+
+3. **Create required directories**
+   ```bash
+   mkdir -p events/active events/archived data logs backup storage
+   chmod -R 755 events data logs backup storage
+   ```
+
+4. **Build and deploy**
+   ```bash
+   docker compose build
+   docker compose up -d
+   ```
+
+5. **Check logs**
+   ```bash
+   docker compose logs -f
+   ```
+
+## 🔧 Configuration
+
+### Essential Environment Variables
+
+Generate secure values:
+```bash
+# JWT Secret
+openssl rand -base64 64
+
+# Database Password (avoid $ character - see warning below)
+openssl rand -base64 32 | tr -d '$'
+
+# Redis Password (avoid $ character - see warning below)
+openssl rand -base64 32 | tr -d '$'
+```
+
+⚠️ **PASSWORD WARNING**: Docker Compose interprets `$` as variable substitution. Either:
+- Avoid `$` in passwords (recommended - use the commands above)
+- Escape `$` as `$$` (e.g., `Pass$$word` instead of `Pass$word`)
+- Quote the entire value: `DB_PASSWORD='Pass$word'` (less reliable)
+
+### Backend Configuration (.env)
+Update `.env` with:
+- `JWT_SECRET` - Authentication secret (REQUIRED - generate a secure random value)
+- `DB_PASSWORD` - PostgreSQL password
+- `REDIS_PASSWORD` - Redis password
+- `SMTP_*` - Email configuration
+- **URL Configuration** (for backend CORS):
+  - `FRONTEND_URL` - Frontend origin (use full URL with scheme, no trailing slash)
+    - Example (Docker): `http://localhost:3000`
+  - `ADMIN_URL` - Admin origin (same as `FRONTEND_URL` for Docker; full URL, no trailing slash)
+    - Example (Docker): `http://localhost:3000`
+  
+  Notes:
+  - Do not include trailing `/` (e.g., use `http://host:3000`, not `http://host:3000/`).
+  - Always include the scheme (`http://` or `https://`).
+  - The backend compares origins strictly for CORS; malformed values will cause login requests to fail with 500.
+
+#### External Database Example
+To use an external PostgreSQL instead of the bundled container, set the following in `.env` and ensure the `postgres` service is disabled or removed:
+
+```env
+DB_HOST=db.example.com
+DB_PORT=5432
+DB_USER=picpeak
+DB_PASSWORD=change_me
+DB_NAME=picpeak_prod
+```
+
+Compose uses these values via `env_file: .env`. The backend service also defaults `DB_HOST=${DB_HOST:-postgres}` so if you don’t set `DB_HOST` it will use the bundled `postgres` container.
+
+### Frontend Configuration (frontend/.env)
+Create `frontend/.env` from `frontend/.env.example`:
+```bash
+cp frontend/.env.example frontend/.env
+```
+
+Update `frontend/.env` with:
+- `VITE_API_URL` - Backend API URL
+  - Docker (pre-built images) and production behind reverse proxy: `/api` (recommended; avoids CORS and matches the frontend Nginx proxy in the image)
+  - Local dev (Vite): `http://localhost:3001` or `/api` if proxying through a dev proxy
+
+Note: When using pre-built frontend images, runtime container env does not change the already-built JS. Prefer the default `/api` and let the frontend Nginx proxy forward to the backend.
+
+⚠️ **IMPORTANT PORT CONFIGURATION**: 
+- The frontend runs on port **3000** in Docker (exposed via nginx)
+- The backend API runs on port **3001**
+- The frontend `.env` file MUST point to the correct backend port (3001)
+- Default `.env.example` is configured for Docker deployment
+
+### Email Configuration Examples
+
+#### Gmail
+```env
+SMTP_HOST=smtp.gmail.com
+SMTP_PORT=587
+SMTP_SECURE=false
+SMTP_USER=your-email@gmail.com
+SMTP_PASS=your-app-specific-password
+```
+
+#### SendGrid
+```env
+SMTP_HOST=smtp.sendgrid.net
+SMTP_PORT=587
+SMTP_SECURE=false
+SMTP_USER=apikey
+SMTP_PASS=your-sendgrid-api-key
+```
+
+## 📦 Deployment
+
+### Using Pre-built Images (Fastest)
+
+```bash
+# Pull latest images from GitHub Container Registry
+docker pull ghcr.io/the-luap/picpeak/backend:latest
+docker pull ghcr.io/the-luap/picpeak/frontend:latest
+
+# Start services using production compose file
+docker compose -f docker-compose.production.yml up -d
+
+# View running containers
+docker compose ps
+```
+
+### Building from Source (For Customization)
+
+```bash
+# Build images locally
+docker compose build
+
+# Or build with no cache for clean build
+docker compose build --no-cache
+
+# Start all services
+docker compose up -d
+
+# View running containers
+docker compose ps
+```
+
+### Access Points
+
+By default, services are exposed on:
+- Frontend (UI + Admin): http://localhost:3000 (admin at `/admin`)
+- Backend/API: http://localhost:3001 (API only; no UI routes)
+- PostgreSQL: localhost:5432 (if needed)
+- Redis: localhost:6379 (if needed)
+
+### Initial Admin Setup
+
+When deploying for the first time, an admin account is automatically created with a secure, randomly generated password. This password is displayed in the Docker logs during initialization and **must be changed** on first login.
+
+#### Finding the Auto-Generated Admin Password
+
+The admin password is automatically generated during the first startup and displayed in the backend container logs. Here's how to find it:
+
+**Option 1: Search Docker logs for admin password** (recommended)
+```bash
+# Find the auto-generated admin password in logs
+docker compose logs backend | grep "Admin password"
+```
+
+You should see output like:
+```
+✅ Admin password generated: BraveTiger6231!
+```
+
+**Option 2: View the complete initialization logs**
+```bash
+# View the complete admin setup logs
+docker compose logs backend | grep -A 10 "Admin user created"
+```
+
+**Option 3: Check the saved credentials file**
+```bash
+# The password is also saved in the backend container
+docker exec picpeak-backend cat data/ADMIN_CREDENTIALS.txt
+```
+
+**Option 4: Use the helper script**
+```bash
+# Show current admin username and email (password is hidden)
+docker exec picpeak-backend node scripts/show-admin-credentials.js
+
+# Reset the admin password to a new random password
+docker exec picpeak-backend node scripts/show-admin-credentials.js --reset
+```
+
+#### Important Security Notes
+
+- **Login requires the email address**, not username
+- The admin password is only displayed once during initial setup
+- **Password change is MANDATORY** on first login - the system will force you to change it
+- If you lose the password before first login, use the `--reset` option to generate a new one
+- New password requirements: minimum 12 characters, mixed case, numbers, and special characters
+
+## 🔐 First Login
+
+After deployment, you must complete the first login process which includes mandatory password change for security.
+
+### Step 1: Locate Your Admin Password
+
+1. **Find the auto-generated password** from the credentials file:
+   ```bash
+   # Docker deployment
+   docker compose exec backend cat /app/data/ADMIN_CREDENTIALS.txt
+   
+   # Or directly from the host (if you have access)
+   cat data/ADMIN_CREDENTIALS.txt
+   ```
+
+2. **Note the admin email** (default: `admin@example.com` unless customized)
+
+### Step 2: Access Admin Panel
+
+1. Navigate to your frontend domain and open the admin section:
+   - `http://your-domain.com/admin` (behind reverse proxy)
+   - `http://localhost:3000/admin` (Docker local)
+   
+   The backend at `:3001` serves API only and does not serve the admin UI.
+2. Login using:
+   - **Email**: `admin@example.com` (or your custom admin email)
+   - **Password**: The auto-generated password from the logs
+
+### Step 3: Mandatory Password Change
+
+Upon first login, the system will **automatically redirect** you to change your password:
+
+1. **You cannot skip this step** - it's enforced for security
+2. Enter the current auto-generated password
+3. Create a new secure password meeting these requirements:
+   - Minimum 12 characters
+   - At least one uppercase letter
+   - At least one lowercase letter
+   - At least one number
+   - At least one special character (!@#$%^&*)
+
+### Security Best Practices for New Password
+
+- **Use a unique password** not used elsewhere
+- **Consider a password manager** for generation and storage
+- **Include mixed characters**: `MySecureP@ssw0rd2024!`
+- **Avoid personal information** (names, dates, etc.)
+- **Save securely** - you cannot recover this password easily
+
+### If You Lose Access
+
+If you lose your admin credentials after the first login, you'll need to manually reset the password in the database or create a new admin user through the database.
+
+**Note**: The credentials file (`ADMIN_CREDENTIALS.txt`) is only created during initial deployment and contains the first admin password. After changing the password, this file becomes outdated but is kept for reference.
+
+#### Configuring Admin Email
+
+By default, the admin email is `admin@example.com`. To use a different email address, set it in your `.env` file before first deployment:
+
+```env
+# .env
+ADMIN_EMAIL=your-email@yourdomain.com
+```
+
+**Note**: This only works on first deployment. To change the admin email after deployment, you'll need to update it in the database or create a new admin user through the admin panel.
+
+## 🔒 Reverse Proxy Setup
+
+For production deployments, you should use a reverse proxy for SSL/HTTPS. The application exposes ports directly, allowing you to use any reverse proxy solution.
+
+### Option 1: Nginx
+
+Install nginx and create `/etc/nginx/sites-available/picpeak`:
+
+```nginx
+server {
+    listen 80;
+    server_name your-domain.com;
+    return 301 https://$server_name$request_uri;
+}
+
+server {
+    listen 443 ssl http2;
+    server_name your-domain.com;
+
+    ssl_certificate /etc/letsencrypt/live/your-domain.com/fullchain.pem;
+    ssl_certificate_key /etc/letsencrypt/live/your-domain.com/privkey.pem;
+
+    # Frontend
+    location / {
+        proxy_pass http://localhost:3000;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+
+    # Frontend (serves UI and /admin/*)
+    location / {
+        proxy_pass http://localhost:3000;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+
+    # Backend API and protected resources
+    location /api {
+        proxy_pass http://localhost:3001;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+    location ~ ^/(photos|thumbnails|uploads) {
+        proxy_pass http://localhost:3001;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+}
+```
+
+Enable the site:
+```bash
+sudo ln -s /etc/nginx/sites-available/picpeak /etc/nginx/sites-enabled/
+sudo nginx -t
+sudo systemctl reload nginx
+```
+
+### Option 2: Traefik
+
+Add labels to `docker-compose.override.yml`:
+
+```yaml
+version: '3.8'
+
+services:
+  frontend:
+    labels:
+      - "traefik.enable=true"
+      - "traefik.http.routers.picpeak.rule=Host(`your-domain.com`)"
+      - "traefik.http.routers.picpeak.entrypoints=websecure"
+      - "traefik.http.routers.picpeak.tls.certresolver=letsencrypt"
+      - "traefik.http.services.picpeak.loadbalancer.server.port=80"
+
+  backend:
+    labels:
+      - "traefik.enable=true"
+      - "traefik.http.routers.picpeak-api.rule=Host(`your-domain.com`) && PathPrefix(`/api`)"
+      - "traefik.http.routers.picpeak-api.entrypoints=websecure"
+      - "traefik.http.routers.picpeak-api.tls.certresolver=letsencrypt"
+      - "traefik.http.services.picpeak-api.loadbalancer.server.port=3001"
+```
+
+### Option 3: Caddy
+
+Create a `Caddyfile`:
+
+```caddyfile
+your-domain.com {
+    # Frontend
+    handle /* {
+        reverse_proxy localhost:3000
+    }
+
+    # Backend API and admin
+    handle /api/* {
+        reverse_proxy localhost:3001
+    }
+    
+    handle /admin/* {
+        reverse_proxy localhost:3001
+    }
+
+    # Protected resources
+    handle /photos/* {
+        reverse_proxy localhost:3001
+    }
+
+    handle /thumbnails/* {
+        reverse_proxy localhost:3001
+    }
+
+    handle /uploads/* {
+        reverse_proxy localhost:3001
+    }
+}
+```
+
+### SSL Certificates
+
+For any reverse proxy, you can use Let's Encrypt:
+
+```bash
+# With Certbot
+sudo certbot certonly --webroot -w /var/www/certbot -d your-domain.com
+
+# Or use your reverse proxy's built-in ACME support
+```
+
+## 🔧 Maintenance
+
+### Viewing Logs
+
+```bash
+# All services
+docker compose logs -f
+
+# Specific service
+docker compose logs -f backend
+docker compose logs -f frontend
+```
+
+### Backup
+
+#### Manual Backup
+```bash
+# Database backup
+docker exec picpeak-postgres pg_dump -U picpeak picpeak_prod > backup/db_$(date +%Y%m%d_%H%M%S).sql
+
+# Files backup
+tar -czf backup/photos_$(date +%Y%m%d_%H%M%S).tar.gz events/
+```
+
+#### Automated Backup
+The application includes a built-in backup service. Configure it in the admin panel:
+1. Login to admin panel
+2. Go to Settings → Backup
+3. Configure destination and schedule
+4. Enable backup service
+
+### Updates
+
+#### Method 1: Using Pre-built Images (Recommended)
+
+```bash
+# Pull latest changes (for configuration updates)
+git pull
+
+# Pull latest images from GitHub Container Registry
+docker compose -f docker-compose.production.yml pull
+
+# Restart with new images
+docker compose -f docker-compose.production.yml down
+docker compose -f docker-compose.production.yml up -d
+
+# Verify services are healthy
+docker compose -f docker-compose.production.yml ps
+```
+
+#### Method 2: Building from Source
+
+```bash
+# Pull latest changes
+git pull
+
+# Rebuild and restart
+docker compose down
+docker compose build --no-cache
+docker compose up -d
+
+# Verify services are healthy
+docker compose ps
+```
+
+#### Specific Version Updates
+
+To use a specific version of the images:
+
+```bash
+# Edit docker-compose.production.yml to specify version tags
+# Change: ghcr.io/the-luap/picpeak/backend:latest
+# To:     ghcr.io/the-luap/picpeak/backend:v1.0.0
+
+# Then pull and restart
+docker compose -f docker-compose.production.yml pull
+docker compose -f docker-compose.production.yml up -d
+```
+
+### Database Migrations
+
+Migrations run automatically on startup, but you can run them manually:
+
+```bash
+docker exec picpeak-backend npm run migrate
+```
+
+## 🚨 Troubleshooting
+
+### Common Issues
+
+#### 502 Bad Gateway / Login Failures
+**This is the most common deployment issue!** Usually caused by misconfigured URLs or network problems:
+
+1. **CORS Configuration Errors**:
+   ```bash
+   # WRONG - Missing port will cause CORS errors
+   FRONTEND_URL=http://10.0.252.12
+   
+   # CORRECT - Include the port you're accessing from
+   FRONTEND_URL=http://10.0.252.12:3000
+   ```
+   
+   The backend validates Origin headers against `FRONTEND_URL` for CORS. If they don't match exactly, you'll get 500 errors on login.
+
+2. **After Container Restarts**:
+   - Nginx may have cached old container IPs
+   - Solution: `docker restart picpeak-frontend`
+   - Always wait 30-60 seconds for health checks
+
+3. **Backend Not Starting After Migrations**:
+   - The logs may only show migrations completed
+   - Check if server is actually running: `docker exec picpeak-backend ps aux | grep node`
+   - Should see `node server.js` process
+
+4. **Login After Fresh Install**:
+   - Check backend logs for auto-generated admin password: `docker compose logs backend | grep "Admin password"`
+   - Email: `admin@example.com` (or your custom admin email from .env)
+   - Password: Auto-generated and shown in logs (e.g., `BraveTiger6231!`)
+   - Remember: Password MUST be changed on first login
+
+5. **Complete Fix Sequence**:
+   ```bash
+   # 1. Fix your .env file URLs
+   # 2. Full restart
+   docker-compose down
+   docker-compose up -d
+   
+   # 3. Wait for healthy status
+   sleep 60
+   docker ps  # All should show (healthy)
+   
+   # 4. Test backend directly
+   curl http://localhost:3001/health
+   
+   # 5. Test through frontend
+   curl http://localhost:3000/api/public/settings
+   ```
+
+#### Port Already in Use
+```bash
+# Check what's using the port
+sudo lsof -i :3000
+sudo lsof -i :3001
+
+# Change ports in .env
+FRONTEND_PORT=3002
+BACKEND_PORT=3003
+```
+
+#### Docker Compose Variable Substitution Errors
+If you see warnings like:
+```
+WARN[0000] The "fgbf" variable is not set. Defaulting to a blank string.
+```
+
+This means your password contains `$` which Docker Compose interprets as a variable. Solutions:
+1. **Best**: Generate passwords without `$`: `openssl rand -base64 32 | tr -d '$'`
+2. **Alternative**: Escape `$` as `$$` in your .env file
+3. **Example**: `DB_PASSWORD=Pass@#$$fgbf` instead of `DB_PASSWORD=Pass@#$fgbf`
+
+#### Permission Errors
+```bash
+# Fix ownership
+sudo chown -R 1000:1000 events data logs backup storage
+chmod -R 755 events data logs backup storage
+```
+
+#### Database Connection Issues
+```bash
+# Check if database is running
+docker compose ps
+docker compose logs postgres
+
+# Test connection
+docker exec picpeak-postgres pg_isready
+```
+
+#### Email Not Sending
+- Verify SMTP settings in .env
+- Check email queue: `docker exec picpeak-backend psql -U picpeak -d picpeak_prod -c "SELECT * FROM email_queue ORDER BY created_at DESC LIMIT 10;"`
+- For Gmail, use app-specific password
+- Check logs: `docker compose logs backend | grep email`
+
+### Health Checks
+
+```bash
+# Backend health
+curl http://localhost:3001/api/health
+
+# Frontend health
+curl http://localhost:3000
+
+# Database health
+docker exec picpeak-postgres pg_isready
+```
+
+### Useful Commands
+
+```bash
+# Enter backend container
+docker exec -it picpeak-backend sh
+
+# Enter database
+docker exec -it picpeak-postgres psql -U picpeak picpeak_prod
+
+# Reset admin password
+docker exec picpeak-backend node scripts/show-admin-credentials.js --reset
+
+# Check disk usage
+df -h
+du -sh events/ storage/ backup/
+
+# View running processes
+docker compose top
+```
+
+## Security Recommendations
+
+1. **Use HTTPS**: Always use a reverse proxy with SSL in production
+2. **Firewall**: Only expose necessary ports (80, 443)
+3. **Secure passwords**: Use strong, unique passwords for all services
+4. **Regular updates**: Keep Docker images and system packages updated
+5. **Backup strategy**: Set up automated backups and test restoration
+6. **Monitor logs**: Regularly check logs for suspicious activity
+7. **Rate limiting**: The app includes built-in rate limiting, configure as needed
+
+## Support
+
+For issues and questions:
+- Check logs first: `docker compose logs`
+- Review documentation in the repository
+- Check existing issues on GitHub
+- Create a new issue with:
+  - Error messages
+  - Log output
+  - Environment details (without secrets)
+  - Steps to reproduce

PRODUCTION_DEPLOYMENT.md

@@ -1,98 +0,0 @@
-# Production Deployment Guide
-
-This guide explains how to deploy PicPeak in production behind a reverse proxy like Traefik.
-
-## Environment Configuration
-
-### Frontend Configuration
-
-For production deployment behind a reverse proxy (Traefik, Nginx, etc.), the frontend should use relative URLs to automatically inherit the protocol (HTTPS) and domain.
-
-1. Copy the production environment template:
-   ```bash
-   cp frontend/.env.production.example frontend/.env.production
-   ```
-
-2. Set the API URL to use relative path:
-   ```env
-   # frontend/.env.production
-   VITE_API_URL=/api
-   ```
-
-   This ensures all API calls will use the same domain and protocol as the frontend.
-
-### Backend Configuration
-
-Ensure your backend `.env` file has the correct URLs:
-```env
-# backend/.env
-FRONTEND_URL=https://yourdomain.com
-ADMIN_URL=https://yourdomain.com
-```
-
-## Docker Compose Production
-
-When using Docker Compose in production:
-
-1. Build with production environment:
-   ```bash
-   docker-compose -f docker-compose.prod.yml build --build-arg NODE_ENV=production
-   ```
-
-2. The frontend nginx configuration already includes proper proxy settings for:
-   - `/api` → Backend API
-   - `/photos` → Protected photo access
-   - `/thumbnails` → Thumbnail images
-   - `/uploads` → Public uploads (logos, favicons)
-
-## Traefik Configuration
-
-Example Traefik labels for docker-compose:
-
-```yaml
-services:
-  frontend:
-    labels:
-      - "traefik.enable=true"
-      - "traefik.http.routers.picpeak.rule=Host(`yourdomain.com`)"
-      - "traefik.http.routers.picpeak.entrypoints=websecure"
-      - "traefik.http.routers.picpeak.tls.certresolver=letsencrypt"
-      - "traefik.http.services.picpeak.loadbalancer.server.port=80"
-```
-
-## Important Notes
-
-1. **No Hardcoded URLs**: The application uses environment variables with relative URL fallbacks, making it production-ready.
-
-2. **HTTPS Only**: When `VITE_API_URL=/api`, all requests will use the same protocol as the page (HTTPS in production).
-
-3. **CORS Configuration**: The backend CORS is configured to accept requests from the URLs specified in `FRONTEND_URL` and `ADMIN_URL`.
-
-4. **Static Assets**: All static assets (photos, thumbnails, uploads) are served through the nginx proxy, inheriting authentication headers.
-
-## Verification
-
-After deployment, verify:
-
-1. Check browser console for any localhost URLs (there should be none)
-2. Verify all API calls use HTTPS
-3. Check that images load correctly with authentication
-4. Test favicon and logo display
-
-## Troubleshooting
-
-If you see console errors about localhost:
-
-1. Ensure `VITE_API_URL=/api` in frontend environment
-2. Clear browser cache
-3. Rebuild frontend with production environment:
-   ```bash
-   cd frontend
-   npm run build
-   ```
-
-If images don't load:
-
-1. Check that nginx proxy locations are configured
-2. Verify authentication tokens are being sent
-3. Check backend logs for authentication errors

PRODUCTION_DEPLOYMENT_GUIDE.md

@@ -1,312 +0,0 @@
-# Production Deployment Guide
-
-This guide addresses all known production deployment issues and provides solutions.
-
-## Pre-Deployment Checklist
-
-### 1. Environment Variables
-Create a `.env` file with ALL required variables:
-
-```bash
-# Required
-JWT_SECRET=<generate-with-openssl-rand-base64-32>
-DB_PASSWORD=<strong-password>
-ADMIN_URL=https://yourdomain.com
-FRONTEND_URL=https://yourdomain.com
-
-# Database
-DB_USER=picpeak
-DB_NAME=picpeak
-
-# Email (Optional but recommended)
-SMTP_HOST=smtp.gmail.com
-SMTP_PORT=587
-SMTP_SECURE=false
-SMTP_USER=your-email@gmail.com
-SMTP_PASS=your-app-password
-EMAIL_FROM=noreply@yourdomain.com
-
-# Umami Analytics (Optional)
-UMAMI_URL=https://analytics.yourdomain.com
-UMAMI_WEBSITE_ID=your-website-id
-UMAMI_HASH_SALT=<generate-random-string>
-```
-
-### 2. Generate Secrets
-
-```bash
-# Generate JWT Secret
-openssl rand -base64 32
-
-# Generate Database Password
-openssl rand -base64 24
-
-# Generate Umami Hash Salt
-openssl rand -hex 32
-```
-
-## Deployment Steps
-
-### 1. Initial Setup
-
-```bash
-# Clone repository
-git clone https://github.com/the-luap/wedding-photo-sharing.git
-cd wedding-photo-sharing
-
-# Create required directories
-mkdir -p storage/events/active storage/events/archived storage/thumbnails storage/uploads
-mkdir -p data logs
-mkdir -p certbot/conf certbot/www
-
-# Set permissions (important!)
-chmod -R 755 storage data logs
-```
-
-### 2. Fix Docker Volume Permissions
-
-Create `docker-compose.override.yml` for local volume configuration:
-
-```yaml
-version: '3.8'
-
-services:
-  backend:
-    volumes:
-      - ./storage:/app/storage:delegated
-      - ./data:/app/data:delegated
-      - ./logs:/app/logs:delegated
-    user: "1001:1001"  # nodejs user
-
-  db:
-    volumes:
-      - ./postgres-data:/var/lib/postgresql/data
-```
-
-### 3. Build and Deploy
-
-```bash
-# Build images
-docker-compose -f docker-compose.prod.yml build
-
-# Start services
-docker-compose -f docker-compose.prod.yml up -d
-
-# Check logs
-docker-compose -f docker-compose.prod.yml logs -f backend
-```
-
-### 4. Create Admin User
-
-After deployment, create the first admin user:
-
-```bash
-# Enter backend container
-docker-compose -f docker-compose.prod.yml exec backend sh
-
-# Create admin
-node scripts/create-admin.js \
-  --username admin \
-  --email admin@yourdomain.com \
-  --password <your-secure-password>
-
-# Exit container
-exit
-```
-
-### 5. Configure Email (if using database config)
-
-1. Login to admin panel: https://yourdomain.com/admin
-2. Go to Settings > Email Configuration
-3. Enter SMTP details
-4. Test email sending
-
-## Common Issues and Solutions
-
-### Issue 1: Migration Failures
-
-**Error**: "relation already exists"
-
-**Solution**: The safe migration runner handles this automatically. If issues persist:
-
-```bash
-# Reset migrations tracking
-docker-compose -f docker-compose.prod.yml exec db psql -U picpeak -d picpeak
-
-# In PostgreSQL:
-DROP TABLE IF EXISTS migrations;
-\q
-
-# Re-run migrations
-docker-compose -f docker-compose.prod.yml exec backend npm run migrate:safe
-```
-
-### Issue 2: Permission Denied Errors
-
-**Error**: "EACCES: permission denied"
-
-**Solution**: Fix container permissions:
-
-```bash
-# Stop containers
-docker-compose -f docker-compose.prod.yml down
-
-# Fix permissions on host
-sudo chown -R 1001:1001 storage data logs
-
-# Restart
-docker-compose -f docker-compose.prod.yml up -d
-```
-
-### Issue 3: Database Connection Failed
-
-**Error**: "no pg_hba.conf entry"
-
-**Solution**: Already fixed in docker-compose.prod.yml with:
-- SSL disabled for internal Docker network
-- Proper authentication method (scram-sha-256)
-
-### Issue 4: Frontend Can't Connect to Backend
-
-**Error**: CORS errors or connection refused
-
-**Solution**: Ensure environment variables match:
-- Backend: `FRONTEND_URL` must match your frontend URL
-- Frontend: `VITE_API_URL` must be set during build
-
-### Issue 5: Email Not Sending
-
-**Solution**: Check email configuration:
-
-```bash
-# Check backend logs
-docker-compose -f docker-compose.prod.yml logs backend | grep email
-
-# Verify SMTP settings
-# Gmail users: Use app password, not regular password
-# Enable "Less secure app access" or use OAuth2
-```
-
-## SSL/HTTPS Setup
-
-1. Update `nginx/sites-enabled/default` with your domain
-2. Run certbot:
-
-```bash
-# Initial certificate
-docker-compose -f docker-compose.prod.yml run --rm certbot certonly \
-  --webroot --webroot-path=/var/www/certbot \
-  -d yourdomain.com -d www.yourdomain.com
-
-# Auto-renewal is handled by the certbot container
-```
-
-## Monitoring
-
-### Health Checks
-
-```bash
-# Backend health
-curl http://localhost/api/health
-
-# Database connection
-docker-compose -f docker-compose.prod.yml exec backend \
-  psql -U picpeak -d picpeak -c "SELECT 1"
-```
-
-### Logs
-
-```bash
-# All services
-docker-compose -f docker-compose.prod.yml logs -f
-
-# Specific service
-docker-compose -f docker-compose.prod.yml logs -f backend
-```
-
-## Backup and Restore
-
-### Backup
-
-```bash
-#!/bin/bash
-# backup.sh
-DATE=$(date +%Y%m%d_%H%M%S)
-BACKUP_DIR="./backups/$DATE"
-
-mkdir -p $BACKUP_DIR
-
-# Database
-docker-compose -f docker-compose.prod.yml exec -T db \
-  pg_dump -U picpeak picpeak > $BACKUP_DIR/database.sql
-
-# Files
-tar -czf $BACKUP_DIR/storage.tar.gz storage/
-
-echo "Backup completed: $BACKUP_DIR"
-```
-
-### Restore
-
-```bash
-# Database
-docker-compose -f docker-compose.prod.yml exec -T db \
-  psql -U picpeak picpeak < ./backups/20240713_120000/database.sql
-
-# Files
-tar -xzf ./backups/20240713_120000/storage.tar.gz
-```
-
-## Production Best Practices
-
-1. **Always use named volumes** in production for better data persistence
-2. **Set up monitoring** with Prometheus/Grafana
-3. **Enable backups** with automated scripts
-4. **Use a reverse proxy** (Nginx) for SSL termination
-5. **Implement rate limiting** at the Nginx level
-6. **Regular updates** - Keep Docker images updated
-7. **Log rotation** - Configure log rotation for application logs
-
-## Troubleshooting Commands
-
-```bash
-# Check running containers
-docker-compose -f docker-compose.prod.yml ps
-
-# Restart a service
-docker-compose -f docker-compose.prod.yml restart backend
-
-# View real-time logs
-docker-compose -f docker-compose.prod.yml logs -f --tail=100
-
-# Execute commands in container
-docker-compose -f docker-compose.prod.yml exec backend sh
-
-# Database shell
-docker-compose -f docker-compose.prod.yml exec db psql -U picpeak
-
-# Clean restart
-docker-compose -f docker-compose.prod.yml down
-docker-compose -f docker-compose.prod.yml up -d
-```
-
-## Security Checklist
-
-- [ ] Strong JWT_SECRET (min 32 chars)
-- [ ] Strong database password
-- [ ] SSL/HTTPS enabled
-- [ ] Firewall configured (only 80/443 open)
-- [ ] Regular security updates
-- [ ] Backup encryption
-- [ ] Access logs monitored
-- [ ] Rate limiting enabled
-- [ ] File upload restrictions configured
-
-## Support
-
-For issues not covered here:
-1. Check application logs
-2. Review error messages carefully
-3. Ensure all environment variables are set
-4. Verify file permissions
-5. Check Docker daemon logs

README.md

@@ -28,6 +28,7 @@ Unlike expensive SaaS solutions, PicPeak gives you:
 
 ### For Photographers
 - 📁 **Drag & Drop Upload** - Simply drop photos into folders
+- 🔗 **External Media (Reference Mode)** - Browse and import from a read‑only external folder library without copying originals
 - ⏰ **Auto-Expiring Galleries** - Set expiration dates (default: 30 days)
 - 🔐 **Password Protection** - Secure client galleries
 - 📧 **Automated Emails** - Creation confirmations and expiration warnings
@@ -40,10 +41,12 @@ Unlike expensive SaaS solutions, PicPeak gives you:
 - ⬇️ **Bulk Downloads** - Download all photos with one click
 - 🔍 **Smart Search** - Find photos quickly
 - 📤 **Guest Uploads** - Optional client photo uploads
+- 🛡️ **Download Protection** - Advanced image protection with watermarking and right-click prevention
 
 ### Technical Excellence
 - 🐳 **Docker Ready** - Deploy in minutes
 - 🔄 **Auto-Processing** - Automatic thumbnail generation
+- 🗂️ **Reference Library Support** - Point PicPeak at `EXTERNAL_MEDIA_ROOT` to reference existing originals, index quickly, and generate thumbnails on demand
 - 💾 **Smart Storage** - Automatic archiving of expired galleries
 - 🛡️ **Security First** - JWT auth, rate limiting, CORS protection
 - 📈 **Scalable** - From small studios to large agencies
@@ -71,7 +74,8 @@ docker-compose up -d
 
 ## 📖 Documentation
 
-- 📘 [**Deployment Guide**](DEPLOYMENT.md) - Detailed installation instructions
+- 📘 [**Deployment Guide**](DEPLOYMENT_GUIDE.md) - Detailed installation instructions
+  - Includes the new [External Media Library](DEPLOYMENT_GUIDE.md#external-media-library) reference mode
 - 🤝 [**Contributing**](CONTRIBUTING.md) - How to contribute
 - 📜 [**License**](LICENSE) - MIT License
 - 🔒 [**Security**](SECURITY.md) - Security policies
@@ -94,6 +98,20 @@ Perfect for:
 - **Email**: SMTP with customizable templates
 - **Analytics**: Privacy-focused with Umami integration
 
+## 💻 System Requirements
+
+### Minimum Requirements
+- **CPU**: 2 CPU cores
+- **RAM**: 2GB minimum
+- **Storage**: 20GB minimum (plus photo storage needs)
+- **OS**: Linux (Ubuntu 20.04+), macOS, or Windows with WSL2
+- **Node.js**: v18.0.0 or higher
+- **Database**: SQLite (included) or PostgreSQL 12+
+
+### Docker Requirements (Recommended)
+- **Docker**: v20.10.0+
+- **Docker Compose**: v2.0.0+
+
 ## 🤝 Contributing
 
 We love contributions! PicPeak is built by photographers, for photographers. Whether you're fixing bugs, adding features, or improving documentation, your help is welcome.
@@ -124,7 +142,7 @@ PicPeak takes security seriously:
 - 📝 Activity logging
 - 🔒 Secure file access
 
-Found a security issue? Please email security@example.com
+Found a security issue? Please open a [security issue](https://github.com/the-luap/picpeak/issues/new?labels=security) on GitHub
 
 ## 📸 Screenshots
 
@@ -159,10 +177,47 @@ Organize and manage your photo galleries with intuitive event management tools.
 
 </details>
 
+## 🗺️ Roadmap
+
+We're constantly improving PicPeak and welcome contributions from our community! If you have ideas for new features or want to help implement existing ones, please open an issue or submit a pull request. Your contributions help make PicPeak better for everyone.
+
+### 🚧 Beta Features (Use at your own risk)
+
+These features are currently in beta testing and may have limited functionality or stability:
+
+| Feature | Description | Status |
+|---------|-------------|--------|
+| **Download Protection** | Advanced image protection system with canvas rendering, invisible watermarking, and right-click prevention to protect your photos from unauthorized downloads | 🧪 Beta |
+| **Simple Deployment Script** | One-click deployment script for quick server setup with automated configuration and dependency installation | 🧪 Beta |
+
+### 📋 Future Enhancements
+
+| Feature | Description | Priority | Status |
+|---------|-------------|----------|---------|
+| **Backup & Restore** | Comprehensive backup system with S3/MinIO support, automated scheduling, and safe restore functionality | High | ✅ Implemented |
+| **External Media Library (Reference Mode)** | Use an external folder library as a read‑only source with import and on‑demand thumbnail generation | High | ✅ Implemented |
+| **Gallery Templates** | Additional gallery layouts and themes (masonry, slideshow, story-style) for different event types | Medium | 🔄 Open |
+| **Face Recognition** | AI-powered face detection to help guests find their photos and create automatic person-based albums | Low | 🔄 Open |
+| **Gallery Feedback** | Allow guests to like, rate, and comment on photos with admin notifications and moderation | Medium | ✅ Implemented |
+| **Video Support** | Upload and display videos alongside photos in galleries with streaming support | Low | 🔄 Open |
+| **Multiple Administrators** | Support for multiple admin accounts with role-based permissions and activity tracking | Low | 📋 Planned |
+
+**Status Legend:** ✅ Implemented | 🚧 In Progress | 🔄 Open | 📋 Planned
+
 ## 🙏 Acknowledgments
 
 PicPeak is inspired by the best features of commercial platforms while remaining completely open source. Special thanks to all contributors who make this project possible.
 
+### 🤖 AI-Assisted Development
+
+This project was generated with the assistance of AI technology, but has been:
+- ✅ **Fully tested end-to-end** by human developers
+- 🔒 **Security audited** with comprehensive security checks
+- 👨‍💻 **Human-reviewed** for code quality and best practices
+- 🧪 **Production-tested** in real-world scenarios
+
+We believe in transparent development practices and the responsible use of AI as a tool to accelerate development while maintaining high standards of quality and security.
+
 ## 📄 License
 
 PicPeak is released under the [MIT License](LICENSE). Use it freely for personal or commercial projects.
@@ -170,7 +225,7 @@ PicPeak is released under the [MIT License](LICENSE). Use it freely for personal
 ## 🚀 Ready to Get Started?
 
 1. ⭐ **Star this repository** to show your support
-2. 📖 Read the [Deployment Guide](DEPLOYMENT.md)
+2. 📖 Read the [Deployment Guide](DEPLOYMENT_GUIDE.md)
 3. 🐛 Report issues or request features
 4. 🤝 Join our community and contribute!
 
@@ -180,6 +235,6 @@ PicPeak is released under the [MIT License](LICENSE). Use it freely for personal
   Made with ❤️ by photographers, for photographers
   <br>
   <a href="https://github.com/the-luap/picpeak">GitHub</a> •
-  <a href="DEPLOYMENT.md">Documentation</a> •
+  <a href="DEPLOYMENT_GUIDE.md">Documentation</a> •
   <a href="https://github.com/the-luap/picpeak/issues">Support</a>
-</p>
+</p>

SECURITY.md

@@ -15,11 +15,14 @@ We take the security of PicPeak seriously. If you have discovered a security vul
 
 ### 1. **Do NOT create a public GitHub issue**
 
-### 2. Email us at security@example.com with:
-- Description of the vulnerability
-- Steps to reproduce
-- Potential impact
-- Suggested fix (if any)
+### 2. Report the vulnerability by:
+- Opening a [security issue](https://github.com/the-luap/picpeak/issues/new?labels=security) on GitHub
+- Mark it clearly as "SECURITY" in the title
+- Include:
+  - Description of the vulnerability
+  - Steps to reproduce
+  - Potential impact
+  - Suggested fix (if any)
 
 ### 3. You can expect:
 - Acknowledgment within 48 hours
@@ -79,7 +82,7 @@ We believe in responsible disclosure. Once a vulnerability is fixed:
 
 ## Contact
 
-- Security issues: security@example.com
-- General support: https://github.com/the-luap/picpeak/issues
+- Security issues: [Create a security issue](https://github.com/the-luap/picpeak/issues/new?labels=security) on GitHub
+- General support: [GitHub Issues](https://github.com/the-luap/picpeak/issues)
 
 Thank you for helping keep PicPeak and its users safe!

SIMPLE_SETUP.md

@@ -0,0 +1,543 @@
+# 🚀 PicPeak Simple Setup Guide
+
+This guide provides easy installation instructions for PicPeak on Linux servers with both Docker and non-Docker options.
+
+## 📋 Quick Start
+
+### One-Line Installation
+
+```bash
+# Download and run the unified setup script
+curl -fsSL https://raw.githubusercontent.com/the-luap/picpeak/main/scripts/setup.sh -o setup.sh && \
+chmod +x setup.sh && \
+sudo ./setup.sh
+```
+
+The script will automatically detect your environment and recommend the best installation method.
+
+## 🎯 Installation Methods
+
+### Method 1: Docker Installation (Recommended)
+Best for: Most users, easy updates, isolated environment
+
+```bash
+sudo ./setup.sh --docker
+```
+
+**Pros:**
+- ✅ Easier installation and updates
+- ✅ Better isolation from system
+- ✅ Consistent environment across platforms
+- ✅ Built-in PostgreSQL and Redis
+
+**Cons:**
+- ❌ Requires more resources (~4GB RAM recommended)
+- ❌ Additional Docker overhead
+
+### Method 2: Native Installation
+Best for: Resource-constrained systems, Raspberry Pi, direct control
+
+```bash
+sudo ./setup.sh --native
+```
+
+**Pros:**
+- ✅ Lower resource usage (~1GB RAM minimum)
+- ✅ Direct system control
+- ✅ No Docker overhead
+- ✅ Better for ARM devices
+
+**Cons:**
+- ❌ More complex setup
+- ❌ System dependencies required
+- ❌ Manual update process
+
+## 📋 System Requirements
+
+### Minimum Requirements
+- **OS**: Ubuntu 20.04+, Debian 11+, Fedora 38+, RHEL/CentOS 8+, Raspberry Pi OS
+- **RAM**: 
+  - Docker: 2GB minimum (4GB recommended)
+  - Native: 1GB minimum (2GB recommended)
+- **Storage**: 2GB for application + space for photos
+- **Network**: Port 3001 (or 80/443 with proxy)
+
+### Supported Platforms
+- ✅ Ubuntu 20.04, 22.04, 24.04
+- ✅ Debian 11, 12
+- ✅ Raspberry Pi OS (32-bit and 64-bit)
+- ✅ Fedora 38, 39, 40
+- ✅ RHEL/CentOS/Rocky/AlmaLinux 8, 9
+
+## 🛠️ Installation Options
+
+### Interactive Mode (Default)
+```bash
+sudo ./setup.sh
+```
+
+The script will prompt you to choose:
+1. Installation method (Docker or Native)
+2. Admin email and password
+3. Domain configuration (optional)
+4. Email server settings (optional)
+5. SSL/HTTPS setup (optional)
+
+### Unattended Installation
+
+#### Docker with full configuration:
+```bash
+sudo ./setup.sh --docker --unattended \
+  --domain photos.example.com \
+  --email admin@example.com \
+  --admin-password SecurePass123 \
+  --smtp-host smtp.gmail.com \
+  --smtp-port 587 \
+  --smtp-user your-email@gmail.com \
+  --smtp-pass your-app-password \
+  --enable-ssl
+```
+
+#### Native with minimal configuration:
+```bash
+sudo ./setup.sh --native --unattended \
+  --email admin@example.com \
+  --admin-password SecurePass123
+```
+
+### Command Line Options
+
+| Option | Description | Example |
+|--------|-------------|---------|
+| `--docker` | Use Docker installation | `--docker` |
+| `--native` | Use native installation | `--native` |
+| `--unattended` | Run without prompts | `--unattended` |
+| `--domain` | Domain for HTTPS setup | `--domain photos.example.com` |
+| `--email` | Admin email address | `--email admin@example.com` |
+| `--admin-password` | Set admin password | `--admin-password MySecurePass` |
+| `--smtp-host` | SMTP server hostname | `--smtp-host smtp.gmail.com` |
+| `--smtp-port` | SMTP server port | `--smtp-port 587` |
+| `--smtp-user` | SMTP username | `--smtp-user user@gmail.com` |
+| `--smtp-pass` | SMTP password | `--smtp-pass app-password` |
+| `--enable-ssl` | Enable HTTPS with Let's Encrypt | `--enable-ssl` |
+| `--port` | Custom port (native only) | `--port 8080` |
+| `--update` | Update existing installation | `--update` |
+| `--uninstall` | Remove installation | `--uninstall` |
+| `--help` | Show help message | `--help` |
+
+## 🏗️ What Gets Installed
+
+### Docker Installation
+```
+~/picpeak/                    # Or custom directory
+├── docker-compose.yml        # Service definitions
+├── .env                      # Configuration
+├── storage/
+│   └── events/              # Photo storage
+│       ├── active/          # Current galleries
+│       └── archived/        # Expired galleries
+├── logs/                    # Application logs
+└── backup/                  # Backup directory
+```
+
+**Services:**
+- PicPeak Backend (Node.js application)
+- PostgreSQL Database
+- Redis Cache
+- Nginx Reverse Proxy (optional)
+- Background Workers
+
+### Native Installation
+```
+/opt/picpeak/                # Installation directory
+├── backend/                 # Application code
+├── events/                  # Photo storage
+│   ├── active/             # Current galleries
+│   └── archived/           # Expired galleries
+├── logs/                   # Application logs
+└── config/                 # Configuration files
+```
+
+**Services (systemd):**
+- `picpeak-backend` - Main application
+- `picpeak-workers` - Background workers
+- `caddy` - Web server (optional)
+
+## 🌐 Access Methods
+
+### Direct Access (Simplest)
+- Docker: `http://your-server:3000` (frontend and admin at `/admin`)
+- Backend/API: `http://your-server:3001` (API only; no UI routes)
+  
+For native installs, serve the built frontend (e.g., with nginx or Caddy) and access the admin at `/admin` on the frontend domain.
+
+### With Domain & HTTPS
+If configured during setup:
+- `https://your-domain.com` - Gallery frontend
+- `https://your-domain.com/admin` - Admin panel
+
+### Behind Existing Proxy
+Add to your Nginx/Apache configuration (split frontend vs backend):
+```nginx
+# Frontend (UI + /admin/*)
+location / {
+    proxy_pass http://localhost:3000;
+    proxy_http_version 1.1;
+    proxy_set_header Upgrade $http_upgrade;
+    proxy_set_header Connection 'upgrade';
+    proxy_set_header Host $host;
+    proxy_cache_bypass $http_upgrade;
+    proxy_set_header X-Real-IP $remote_addr;
+    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+    proxy_set_header X-Forwarded-Proto $scheme;
+}
+
+# Backend API and protected resources
+location /api {
+    proxy_pass http://localhost:3001;
+    proxy_http_version 1.1;
+    proxy_set_header Upgrade $http_upgrade;
+    proxy_set_header Connection 'upgrade';
+    proxy_set_header Host $host;
+    proxy_cache_bypass $http_upgrade;
+    proxy_set_header X-Real-IP $remote_addr;
+    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+    proxy_set_header X-Forwarded-Proto $scheme;
+    client_max_body_size 100M;
+}
+location ~ ^/(photos|thumbnails|uploads) {
+    proxy_pass http://localhost:3001;
+    proxy_http_version 1.1;
+    proxy_set_header Host $host;
+    proxy_set_header X-Real-IP $remote_addr;
+    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+    proxy_set_header X-Forwarded-Proto $scheme;
+}
+```
+
+## 📁 Managing Galleries
+
+### Creating a Gallery
+
+#### Method 1: Via Admin Panel (Recommended)
+1. Login to admin panel
+2. Click "Create New Event"
+3. Configure settings and upload photos
+
+#### Method 2: File System
+```bash
+# Docker installation
+mkdir -p ~/picpeak/storage/events/active/wedding-smith-2024
+cp /path/to/photos/* ~/picpeak/storage/events/active/wedding-smith-2024/
+
+# Native installation
+sudo mkdir -p /opt/picpeak/events/active/wedding-smith-2024
+sudo cp /path/to/photos/* /opt/picpeak/events/active/wedding-smith-2024/
+sudo chown -R picpeak:picpeak /opt/picpeak/events/active/wedding-smith-2024
+```
+
+### Gallery Structure
+```
+wedding-smith-2024/
+├── collages/        # Group photos
+├── individual/      # Individual photos
+└── thumbnails/      # Auto-generated thumbnails
+```
+
+## 🔧 Service Management
+
+### Docker Installation
+
+```bash
+cd ~/picpeak
+
+# Check status
+docker compose ps
+
+# View logs
+docker compose logs -f
+
+# Stop services
+docker compose down
+
+# Start services
+docker compose up -d
+
+# Restart services
+docker compose restart
+
+# Update PicPeak
+docker compose pull
+docker compose up -d
+```
+
+### Native Installation
+
+```bash
+# Check status
+sudo systemctl status picpeak-backend
+sudo systemctl status picpeak-workers
+
+# View logs
+sudo journalctl -u picpeak-backend -f
+sudo journalctl -u picpeak-workers -f
+
+# Start services
+sudo systemctl start picpeak-backend picpeak-workers
+
+# Stop services
+sudo systemctl stop picpeak-backend picpeak-workers
+
+# Restart services
+sudo systemctl restart picpeak-backend picpeak-workers
+
+# Update PicPeak
+sudo ./setup.sh --update
+```
+
+## ⚙️ Configuration
+
+### Docker Configuration
+Edit `~/picpeak/.env`:
+```bash
+nano ~/picpeak/.env
+docker compose restart
+```
+
+### Native Configuration
+Edit `/opt/picpeak/app/backend/.env`:
+```bash
+sudo nano /opt/picpeak/app/backend/.env
+sudo systemctl restart picpeak-backend
+```
+
+### Key Settings
+
+| Setting | Description | Default |
+|---------|-------------|---------|
+| `JWT_SECRET` | Token signing secret | Auto-generated |
+| `ADMIN_EMAIL` | Admin email | admin@example.com |
+| `ADMIN_PASSWORD` | Admin password | Auto-generated |
+| `PHOTOS_DIR` | Photo storage path | Varies by method |
+| `SMTP_ENABLED` | Email notifications | false |
+| `DEFAULT_EXPIRY_DAYS` | Gallery expiration | 30 |
+
+## 📧 Email Configuration
+
+### Gmail Setup
+1. Enable 2-Factor Authentication
+2. Generate App Password
+3. Configure:
+```env
+SMTP_ENABLED=true
+SMTP_HOST=smtp.gmail.com
+SMTP_PORT=587
+SMTP_SECURE=false
+SMTP_USER=your-email@gmail.com
+SMTP_PASS=your-app-password
+SMTP_FROM=noreply@yourdomain.com
+```
+
+### SendGrid Setup
+1. Sign up at sendgrid.com (100 emails/day free)
+2. Create API key
+3. Configure:
+```env
+SMTP_ENABLED=true
+SMTP_HOST=smtp.sendgrid.net
+SMTP_PORT=587
+SMTP_USER=apikey
+SMTP_PASS=your-sendgrid-api-key
+SMTP_FROM=verified-sender@yourdomain.com
+```
+
+## 🔄 Maintenance
+
+### Backups
+
+#### Docker:
+```bash
+# Backup script included
+cd ~/picpeak
+./backup.sh
+
+# Manual backup
+docker exec picpeak-postgres pg_dump -U picpeak picpeak > backup.sql
+tar -czf photos-backup.tar.gz storage/events/
+```
+
+#### Native:
+```bash
+# Database backup
+sudo cp /opt/picpeak/app/backend/data/photo_sharing.db /backup/database-$(date +%Y%m%d).sqlite
+
+# Photos backup
+sudo tar -czf /backup/photos-$(date +%Y%m%d).tar.gz /opt/picpeak/events/
+```
+
+### Updates
+
+```bash
+# Docker
+cd ~/picpeak
+docker compose pull
+docker compose up -d
+
+# Native
+sudo ./setup.sh --update
+```
+
+### Uninstall
+
+```bash
+# Will prompt for confirmation and data removal options
+sudo ./setup.sh --uninstall
+```
+
+## 🐛 Troubleshooting
+
+### Common Issues
+
+#### Service Won't Start
+```bash
+# Docker
+docker compose logs backend
+docker compose down && docker compose up -d
+
+# Native
+sudo journalctl -u picpeak-backend -n 50
+sudo systemctl restart picpeak-backend
+```
+
+#### Can't Access Admin Panel
+1. Check firewall:
+```bash
+# Ubuntu/Debian
+sudo ufw allow 3001
+
+# RHEL/CentOS
+sudo firewall-cmd --add-port=3001/tcp --permanent
+sudo firewall-cmd --reload
+```
+
+2. Verify service:
+```bash
+# Docker
+curl http://localhost:3001/api/health
+
+# Native
+sudo systemctl is-active picpeak-backend
+```
+
+#### Photos Not Showing
+```bash
+# Check permissions (Native)
+sudo chown -R picpeak:picpeak /opt/picpeak/events/
+sudo chmod -R 755 /opt/picpeak/events/
+
+# Check permissions (Docker)
+ls -la ~/picpeak/storage/events/
+```
+
+#### Reset Admin Password
+
+```bash
+# Docker
+docker exec picpeak-backend node scripts/reset-admin-password.js
+
+# Native
+cd /opt/picpeak/app/backend
+sudo -u picpeak node scripts/reset-admin-password.js
+```
+
+### Getting Help
+
+1. **Check logs:**
+   - Docker: `docker compose logs -f`
+   - Native: `sudo journalctl -u picpeak-backend -f`
+   - Installation: `/tmp/picpeak-setup-*.log`
+
+2. **Documentation:**
+   - [Full Documentation](https://github.com/the-luap/picpeak)
+   - [Deployment Guide](./DEPLOYMENT_GUIDE.md)
+
+3. **Support:**
+   - [GitHub Issues](https://github.com/the-luap/picpeak/issues)
+   - Include: Error messages, system info (`uname -a`), installation method
+
+## 🔒 Security Best Practices
+
+### Essential Security
+1. **Change default admin password immediately**
+2. **Use HTTPS for production** (Let's Encrypt included)
+3. **Configure firewall** (only open necessary ports)
+4. **Regular updates** (system and PicPeak)
+5. **Automated backups** (configure in admin panel)
+
+### Advanced Security
+- Use VPN for admin panel access
+- Configure fail2ban for brute force protection
+- Enable audit logging
+- Regular security scans
+- Implement IP whitelisting
+
+## 📊 Performance Optimization
+
+### Docker Optimization
+```yaml
+# Adjust in docker-compose.yml
+services:
+  backend:
+    deploy:
+      resources:
+        limits:
+          cpus: '2'
+          memory: 2G
+```
+
+### Native Optimization
+```bash
+# Increase Node.js memory
+echo "NODE_OPTIONS=--max-old-space-size=2048" >> /opt/picpeak/app/backend/.env
+sudo systemctl restart picpeak-backend
+```
+
+## 🎯 Quick Setup Examples
+
+### Home/Office Network
+```bash
+# Simple local setup without domain
+sudo ./setup.sh --native --email admin@local.com
+```
+
+### Public Website with HTTPS
+```bash
+# Full production setup
+sudo ./setup.sh --docker \
+  --domain photos.company.com \
+  --email admin@company.com \
+  --enable-ssl
+```
+
+### Raspberry Pi Setup
+```bash
+# Optimized for ARM devices
+sudo ./setup.sh --native \
+  --port 8080 \
+  --email pi@local.com
+```
+
+## ✅ Post-Installation Checklist
+
+- [ ] Admin password changed
+- [ ] Email configuration tested
+- [ ] First test gallery created
+- [ ] Backup schedule configured
+- [ ] Firewall rules applied
+- [ ] SSL certificate working (if applicable)
+- [ ] Monitoring setup
+- [ ] Documentation bookmarked
+
+---
+
+**PicPeak Setup v1.0** | [Documentation](https://github.com/the-luap/picpeak) | [Support](https://github.com/the-luap/picpeak/issues)

backend/.env.example

@@ -3,39 +3,57 @@
 
 # Application
 NODE_ENV=production
-PORT=3000
+PORT=3001
 
 # Security
-JWT_SECRET=your-very-secure-jwt-secret-at-least-32-characters-long
+# Generate with: openssl rand -base64 32
+JWT_SECRET=your-very-secure-jwt-secret-at-least-32-characters-long-example123456
 
-# URLs
-ADMIN_URL=https://yourdomain.com
-FRONTEND_URL=https://yourdomain.com
+# URLs (adjust for your domain)
+ADMIN_URL=https://photos.example.com
+FRONTEND_URL=https://photos.example.com
+BACKEND_URL=https://photos.example.com  # Or https://api.photos.example.com if separate
 
 # Database Configuration
 DATABASE_CLIENT=pg
-DB_HOST=db
+DB_HOST=localhost
 DB_PORT=5432
 DB_USER=picpeak
-DB_PASSWORD=your-secure-database-password
+DB_PASSWORD=your-secure-database-password-change-this
 DB_NAME=picpeak
 
-# Email Configuration
-SMTP_HOST=smtp.example.com
+# Email Configuration (Examples for common providers)
+# Gmail example:
+# SMTP_HOST=smtp.gmail.com
+# SMTP_PORT=587
+# SMTP_SECURE=false
+# SMTP_USER=your-email@gmail.com
+# SMTP_PASS=your-app-specific-password
+
+# SendGrid example:
+SMTP_HOST=smtp.sendgrid.net
 SMTP_PORT=587
 SMTP_SECURE=false
-SMTP_USER=your-smtp-username
-SMTP_PASS=your-smtp-password
-EMAIL_FROM=noreply@yourdomain.com
+SMTP_USER=apikey
+SMTP_PASS=your-sendgrid-api-key
+EMAIL_FROM=noreply@example.com
 
-# Storage Paths (Docker)
+# Storage Paths
+# Docker deployment:
 STORAGE_PATH=/app/storage
 EVENTS_PATH=/app/storage/events
 ARCHIVE_PATH=/app/storage/events/archived
 
-# Analytics (Optional)
-UMAMI_URL=https://analytics.yourdomain.com
-UMAMI_WEBSITE_ID=your-website-id
+# Local development:
+# STORAGE_PATH=./storage
+# EVENTS_PATH=./storage/events
+# ARCHIVE_PATH=./storage/events/archived
+
+# Analytics Backend Configuration (OPTIONAL)
+# Used for server-side tracking only
+# Primary configuration should be done through Admin UI > Settings > Analytics
+# UMAMI_URL=https://analytics.example.com
+# UMAMI_WEBSITE_ID=b4d3c2a1-5678-90ab-cdef-1234567890ab
 
 # Logging
 LOG_LEVEL=info

backend/Dockerfile

@@ -1,7 +1,15 @@
 FROM node:18-alpine AS builder
 
-# Add build argument for cache busting
+# Add build arguments
 ARG CACHEBUST=1
+ARG BUILD_DATE
+ARG VCS_REF
+ARG VERSION
+
+# Add labels for GitHub Container Registry
+LABEL org.opencontainers.image.source="https://github.com/the-luap/picpeak"
+LABEL org.opencontainers.image.description="PicPeak Backend Service"
+LABEL org.opencontainers.image.licenses="MIT"
 
 WORKDIR /app
 

backend/__tests__/README.md

@@ -0,0 +1,229 @@
+# Enhanced Backup System Test Suite
+
+This directory contains comprehensive tests for the enhanced backup system with S3 support.
+
+## Test Structure
+
+### Unit Tests
+- `services/backupService.enhanced.test.js` - Unit tests for the enhanced backup service
+  - Configuration management
+  - S3 backup functionality
+  - Manifest generation
+  - Error handling and recovery
+  - Backward compatibility (local and rsync)
+  - Service lifecycle management
+
+### Integration Tests
+- `integration/backup-s3.test.js` - Integration tests for S3 backups
+  - Real S3/MinIO connection tests
+  - Full backup process with actual files
+  - Incremental backup verification
+  - Manifest storage and retrieval
+  - Error recovery scenarios
+
+### Manual Integration Test Script
+- `../scripts/test-backup-integration.js` - Comprehensive manual testing script
+  - Can test against MinIO, AWS S3, or any S3-compatible service
+  - Tests all backup types (S3, local, rsync)
+  - Performance testing with large files
+  - Detailed progress reporting
+
+## Running Tests
+
+### Prerequisites
+
+1. **For Unit Tests**: No special setup required, all dependencies are mocked.
+
+2. **For Integration Tests**: Requires a running S3-compatible service (MinIO recommended)
+   ```bash
+   # Start MinIO using Docker
+   docker run -d \
+     -p 9000:9000 \
+     -p 9001:9001 \
+     --name minio-test \
+     -e MINIO_ROOT_USER=minioadmin \
+     -e MINIO_ROOT_PASSWORD=minioadmin \
+     minio/minio server /data --console-address ":9001"
+   ```
+
+3. **Environment Variables** (for integration tests):
+   ```bash
+   # Optional - defaults work with local MinIO
+   export TEST_S3_ENDPOINT=http://localhost:9000
+   export TEST_S3_ACCESS_KEY=minioadmin
+   export TEST_S3_SECRET_KEY=minioadmin
+   
+   # Skip S3 tests if no S3 service available
+   export SKIP_S3_TESTS=true
+   ```
+
+### Running Unit Tests
+
+```bash
+# Run all backup service tests
+npm test -- __tests__/services/backupService.enhanced.test.js
+
+# Run specific test suite
+npm test -- __tests__/services/backupService.enhanced.test.js -t "S3 Backup Functionality"
+
+# Run with coverage
+npm test -- --coverage __tests__/services/backupService.enhanced.test.js
+```
+
+### Running Integration Tests
+
+```bash
+# Ensure MinIO is running first!
+
+# Run S3 integration tests
+npm test -- __tests__/integration/backup-s3.test.js
+
+# Run with verbose output
+npm test -- __tests__/integration/backup-s3.test.js --verbose
+
+# Skip S3 tests if needed
+SKIP_S3_TESTS=true npm test -- __tests__/integration/backup-s3.test.js
+```
+
+### Running Manual Integration Tests
+
+```bash
+# Test with local MinIO (default)
+node scripts/test-backup-integration.js
+
+# Test with AWS S3
+node scripts/test-backup-integration.js \
+  --endpoint https://s3.amazonaws.com \
+  --access-key YOUR_ACCESS_KEY \
+  --secret-key YOUR_SECRET_KEY \
+  --bucket your-test-bucket
+
+# Test local backup
+node scripts/test-backup-integration.js --type local
+
+# Test with cleanup after completion
+node scripts/test-backup-integration.js --cleanup
+
+# Verbose output
+node scripts/test-backup-integration.js --verbose
+```
+
+## Test Coverage
+
+The test suite covers:
+
+### Configuration
+- ✅ Database configuration retrieval
+- ✅ JSON parsing and error handling
+- ✅ Configuration validation
+- ✅ Required field validation
+
+### S3 Functionality
+- ✅ S3 client initialization
+- ✅ Connection testing
+- ✅ File upload with progress tracking
+- ✅ Large file handling (multipart upload)
+- ✅ Metadata and custom headers
+- ✅ Error handling and retries
+
+### Backup Process
+- ✅ Full backup execution
+- ✅ Incremental backup (changed files only)
+- ✅ File checksum calculation and comparison
+- ✅ Database backup inclusion
+- ✅ Archive inclusion toggle
+- ✅ File size limits
+
+### Manifest Generation
+- ✅ Full manifest generation
+- ✅ Incremental manifest with parent reference
+- ✅ JSON and YAML format support
+- ✅ Manifest validation
+- ✅ S3 manifest storage and retrieval
+- ✅ Checksum verification
+
+### Error Handling
+- ✅ S3 connection failures
+- ✅ File read errors
+- ✅ Individual file failure recovery
+- ✅ Retry logic with exponential backoff
+- ✅ Email notifications on failure
+- ✅ Concurrent backup prevention
+
+### Backward Compatibility
+- ✅ Local directory backup
+- ✅ Rsync backup
+- ✅ Existing manifest format support
+
+### Service Management
+- ✅ Cron job scheduling
+- ✅ Service start/stop
+- ✅ Manual backup triggering
+- ✅ Backup history and status
+
+## Mock Setup
+
+The unit tests use comprehensive mocking:
+
+```javascript
+// Database mocking
+jest.mock('../../src/database/db');
+
+// S3 client mocking
+jest.mock('../../src/services/storage/s3Storage');
+
+// File system mocking
+const mockFs = require('mock-fs');
+
+// Cron job mocking
+jest.mock('node-cron');
+```
+
+## CI/CD Integration
+
+To run tests in CI/CD pipeline:
+
+```yaml
+# Example GitHub Actions
+- name: Run Unit Tests
+  run: npm test -- __tests__/services/backupService.enhanced.test.js
+
+- name: Start MinIO
+  run: |
+    docker run -d \
+      -p 9000:9000 \
+      --name minio-test \
+      -e MINIO_ROOT_USER=minioadmin \
+      -e MINIO_ROOT_PASSWORD=minioadmin \
+      minio/minio server /data
+
+- name: Run Integration Tests
+  run: npm test -- __tests__/integration/backup-s3.test.js
+```
+
+## Debugging Tests
+
+```bash
+# Run tests in debug mode
+node --inspect-brk ./node_modules/.bin/jest __tests__/services/backupService.enhanced.test.js
+
+# Run single test with console output
+npm test -- __tests__/services/backupService.enhanced.test.js -t "should perform S3 backup" --verbose
+```
+
+## Performance Considerations
+
+- Integration tests create real files and S3 objects
+- Each test run creates a unique S3 bucket to avoid conflicts
+- Cleanup is automatic but can be disabled for debugging
+- Large file tests (10MB+) are included but can be slow
+
+## Adding New Tests
+
+When adding new backup features:
+
+1. Add unit tests to `backupService.enhanced.test.js`
+2. Add integration tests to `backup-s3.test.js` if S3-specific
+3. Update manual test script for comprehensive testing
+4. Ensure mocks are properly configured
+5. Document any new environment requirements

backend/__tests__/integration/backup-s3.test.js

@@ -0,0 +1,506 @@
+const { describe, it, expect, jest, beforeAll, afterAll, beforeEach, afterEach } = require('@jest/globals');
+const { S3Client, CreateBucketCommand, DeleteBucketCommand, ListObjectsV2Command, DeleteObjectsCommand } = require('@aws-sdk/client-s3');
+const path = require('path');
+const fs = require('fs').promises;
+const crypto = require('crypto');
+
+// Load services
+const backupService = require('../../src/services/backupService');
+const S3StorageAdapter = require('../../src/services/storage/s3Storage');
+const { db, initialize: initDb } = require('../../src/database/db');
+const logger = require('../../src/utils/logger');
+
+// Test configuration
+const TEST_CONFIG = {
+  endpoint: process.env.TEST_S3_ENDPOINT || 'http://localhost:9000',
+  accessKeyId: process.env.TEST_S3_ACCESS_KEY || 'minioadmin',
+  secretAccessKey: process.env.TEST_S3_SECRET_KEY || 'minioadmin',
+  bucket: 'test-backup-bucket-' + Date.now(),
+  region: 'us-east-1'
+};
+
+describe('S3 Backup Integration Tests', () => {
+  let s3Client;
+  let testStoragePath;
+  let originalEnv;
+
+  beforeAll(async () => {
+    // Skip if no S3 endpoint configured
+    if (process.env.SKIP_S3_TESTS === 'true') {
+      console.log('Skipping S3 integration tests (SKIP_S3_TESTS=true)');
+      return;
+    }
+
+    // Save original environment
+    originalEnv = { ...process.env };
+
+    // Initialize S3 client for test setup
+    s3Client = new S3Client({
+      endpoint: TEST_CONFIG.endpoint,
+      region: TEST_CONFIG.region,
+      credentials: {
+        accessKeyId: TEST_CONFIG.accessKeyId,
+        secretAccessKey: TEST_CONFIG.secretAccessKey
+      },
+      forcePathStyle: true
+    });
+
+    // Create test bucket
+    try {
+      await s3Client.send(new CreateBucketCommand({ Bucket: TEST_CONFIG.bucket }));
+      console.log(`Created test bucket: ${TEST_CONFIG.bucket}`);
+    } catch (error) {
+      if (error.name !== 'BucketAlreadyOwnedByYou') {
+        console.error('Failed to create test bucket:', error);
+        throw error;
+      }
+    }
+
+    // Initialize database
+    await initDb();
+    await db.migrate.latest();
+
+    // Create test storage directory
+    testStoragePath = path.join(__dirname, '../fixtures/test-storage');
+    await fs.mkdir(testStoragePath, { recursive: true });
+    process.env.STORAGE_PATH = testStoragePath;
+
+    // Set up test data
+    await setupTestData();
+
+    // Mock logger to reduce noise
+    logger.info = jest.fn();
+    logger.debug = jest.fn();
+    logger.warn = jest.fn();
+    logger.error = jest.fn();
+  });
+
+  afterAll(async () => {
+    if (process.env.SKIP_S3_TESTS === 'true') return;
+
+    try {
+      // Clean up S3 bucket
+      await cleanupS3Bucket();
+      await s3Client.send(new DeleteBucketCommand({ Bucket: TEST_CONFIG.bucket }));
+      console.log(`Deleted test bucket: ${TEST_CONFIG.bucket}`);
+    } catch (error) {
+      console.error('Failed to cleanup S3 bucket:', error);
+    }
+
+    // Clean up test storage
+    await fs.rm(testStoragePath, { recursive: true, force: true });
+
+    // Restore environment
+    process.env = originalEnv;
+
+    // Close database
+    await db.destroy();
+  });
+
+  beforeEach(async () => {
+    if (process.env.SKIP_S3_TESTS === 'true') {
+      return;
+    }
+
+    // Clean backup tables
+    await db('backup_runs').del();
+    await db('backup_file_states').del();
+    await db('database_backup_runs').del();
+
+    // Configure S3 backup settings
+    await configureS3Backup();
+  });
+
+  afterEach(async () => {
+    if (process.env.SKIP_S3_TESTS === 'true') return;
+
+    // Clean up S3 objects created during test
+    await cleanupS3Bucket();
+  });
+
+  describe('S3 Connection and Configuration', () => {
+    it('should successfully connect to S3-compatible storage', async () => {
+      if (process.env.SKIP_S3_TESTS === 'true') return;
+
+      const s3Adapter = new S3StorageAdapter({
+        ...TEST_CONFIG,
+        bucket: TEST_CONFIG.bucket,
+        forcePathStyle: true,
+        sslEnabled: false
+      });
+
+      const connected = await s3Adapter.testConnection();
+      expect(connected).toBe(true);
+    });
+
+    it('should validate S3 configuration before backup', async () => {
+      if (process.env.SKIP_S3_TESTS === 'true') return;
+
+      // Remove required configuration
+      await db('app_settings')
+        .where('setting_key', 'backup_s3_secret_key')
+        .del();
+
+      await backupService.runBackup();
+
+      const lastRun = await db('backup_runs')
+        .orderBy('started_at', 'desc')
+        .first();
+
+      expect(lastRun.status).toBe('failed');
+      expect(lastRun.error_message).toContain('S3 backup configuration incomplete');
+    });
+  });
+
+  describe('Full S3 Backup Process', () => {
+    it('should perform complete S3 backup with all file types', async () => {
+      if (process.env.SKIP_S3_TESTS === 'true') return;
+
+      // Run backup
+      await backupService.runBackup();
+
+      // Verify backup run completed
+      const backupRun = await db('backup_runs')
+        .orderBy('started_at', 'desc')
+        .first();
+
+      expect(backupRun.status).toBe('completed');
+      expect(backupRun.files_backed_up).toBeGreaterThan(0);
+      expect(backupRun.total_size_bytes).toBeGreaterThan(0);
+
+      // Verify files in S3
+      const s3Objects = await listS3Objects();
+      expect(s3Objects.length).toBeGreaterThan(0);
+
+      // Check for expected file types
+      const hasPhotos = s3Objects.some(obj => obj.Key.includes('events/active'));
+      const hasThumbnails = s3Objects.some(obj => obj.Key.includes('thumbnails'));
+      const hasManifest = s3Objects.some(obj => obj.Key.includes('backup-manifest'));
+      const hasSummary = s3Objects.some(obj => obj.Key.includes('backup-summary.json'));
+
+      expect(hasPhotos).toBe(true);
+      expect(hasThumbnails).toBe(true);
+      expect(hasManifest).toBe(true);
+      expect(hasSummary).toBe(true);
+    });
+
+    it('should handle large file uploads with multipart', async () => {
+      if (process.env.SKIP_S3_TESTS === 'true') return;
+
+      // Create a large test file (15MB)
+      const largeFilePath = path.join(testStoragePath, 'events/active/large-photo.jpg');
+      const largeFileSize = 15 * 1024 * 1024; // 15MB
+      const largeFileContent = Buffer.alloc(largeFileSize, 'x');
+      await fs.writeFile(largeFilePath, largeFileContent);
+
+      // Run backup
+      await backupService.runBackup();
+
+      // Verify large file was uploaded
+      const s3Objects = await listS3Objects();
+      const largeFileUploaded = s3Objects.some(obj => 
+        obj.Key.includes('large-photo.jpg') && obj.Size === largeFileSize
+      );
+
+      expect(largeFileUploaded).toBe(true);
+    });
+
+    it('should include database backup when available', async () => {
+      if (process.env.SKIP_S3_TESTS === 'true') return;
+
+      // Create a mock database backup
+      const dbBackupPath = path.join(testStoragePath, 'backups/db-backup.sql');
+      await fs.mkdir(path.dirname(dbBackupPath), { recursive: true });
+      await fs.writeFile(dbBackupPath, 'CREATE TABLE test (id INT);');
+
+      // Record database backup
+      await db('database_backup_runs').insert({
+        started_at: new Date(),
+        completed_at: new Date(),
+        status: 'completed',
+        backup_type: 'sqlite',
+        file_path: dbBackupPath,
+        file_size_bytes: 100,
+        checksum: 'test123',
+        statistics: JSON.stringify({ tables: {} }),
+        table_checksums: JSON.stringify({})
+      });
+
+      // Configure to include database
+      await db('app_settings')
+        .where('setting_key', 'backup_include_database')
+        .update({ setting_value: 'true' });
+
+      // Run backup
+      await backupService.runBackup();
+
+      // Verify database backup in S3
+      const s3Objects = await listS3Objects();
+      const hasDbBackup = s3Objects.some(obj => obj.Key.includes('database/db-backup.sql'));
+      expect(hasDbBackup).toBe(true);
+    });
+  });
+
+  describe('Incremental Backup', () => {
+    it('should only upload changed files in incremental backup', async () => {
+      if (process.env.SKIP_S3_TESTS === 'true') return;
+
+      // First backup - full
+      await backupService.runBackup();
+
+      const firstRun = await db('backup_runs')
+        .orderBy('started_at', 'desc')
+        .first();
+
+      const firstObjectCount = (await listS3Objects()).length;
+
+      // Wait a moment to ensure different timestamps
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      // Modify one file
+      const modifiedFile = path.join(testStoragePath, 'events/active/event1/photo1.jpg');
+      await fs.writeFile(modifiedFile, 'modified content');
+
+      // Second backup - incremental
+      await backupService.runBackup();
+
+      const secondRun = await db('backup_runs')
+        .orderBy('started_at', 'desc')
+        .first();
+
+      expect(secondRun.id).not.toBe(firstRun.id);
+      expect(secondRun.files_backed_up).toBe(1); // Only modified file
+
+      // Check manifest indicates incremental
+      if (secondRun.manifest_path) {
+        const manifest = await backupService.getBackupManifest(secondRun.id);
+        expect(manifest.manifest.incremental).toBeDefined();
+        expect(manifest.manifest.incremental.modified_files_count).toBe(1);
+      }
+    });
+
+    it('should track file states across backups', async () => {
+      if (process.env.SKIP_S3_TESTS === 'true') return;
+
+      await backupService.runBackup();
+
+      // Check file states are recorded
+      const fileStates = await db('backup_file_states').select('*');
+      expect(fileStates.length).toBeGreaterThan(0);
+
+      // Verify checksums are stored
+      const hasChecksums = fileStates.every(state => state.checksum !== null);
+      expect(hasChecksums).toBe(true);
+    });
+  });
+
+  describe('S3 Manifest Storage', () => {
+    it('should upload manifest to S3 and retrieve it', async () => {
+      if (process.env.SKIP_S3_TESTS === 'true') return;
+
+      // Configure YAML manifest format
+      await db('app_settings')
+        .where('setting_key', 'backup_manifest_format')
+        .update({ setting_value: '"yaml"' });
+
+      await backupService.runBackup();
+
+      const backupRun = await db('backup_runs')
+        .orderBy('started_at', 'desc')
+        .first();
+
+      expect(backupRun.manifest_path).toMatch(/^s3:\/\//);
+
+      // Retrieve manifest
+      const { manifest, summary } = await backupService.getBackupManifest(backupRun.id);
+
+      expect(manifest).toBeDefined();
+      expect(manifest.backup.id).toBeDefined();
+      expect(summary).toContain('BACKUP MANIFEST SUMMARY');
+    });
+
+    it('should validate manifest integrity', async () => {
+      if (process.env.SKIP_S3_TESTS === 'true') return;
+
+      await backupService.runBackup();
+
+      const backupRun = await db('backup_runs')
+        .orderBy('started_at', 'desc')
+        .first();
+
+      const validationResult = await backupService.validateBackupManifest(backupRun.manifest_path);
+
+      expect(validationResult.valid).toBe(true);
+      expect(validationResult.manifest).toBeDefined();
+    });
+  });
+
+  describe('Error Recovery', () => {
+    it('should handle S3 connection failures gracefully', async () => {
+      if (process.env.SKIP_S3_TESTS === 'true') return;
+
+      // Configure with invalid endpoint
+      await db('app_settings')
+        .where('setting_key', 'backup_s3_endpoint')
+        .update({ setting_value: '"http://invalid-endpoint:9999"' });
+
+      await backupService.runBackup();
+
+      const backupRun = await db('backup_runs')
+        .orderBy('started_at', 'desc')
+        .first();
+
+      expect(backupRun.status).toBe('failed');
+      expect(backupRun.error_message).toBeDefined();
+    });
+
+    it('should continue backup despite individual file failures', async () => {
+      if (process.env.SKIP_S3_TESTS === 'true') return;
+
+      // Create a file that will be deleted during backup
+      const tempFile = path.join(testStoragePath, 'events/active/temp.jpg');
+      await fs.writeFile(tempFile, 'temporary');
+
+      // Mock file deletion during backup
+      const originalUpload = S3StorageAdapter.prototype.upload;
+      let callCount = 0;
+      S3StorageAdapter.prototype.upload = jest.fn(async function(localPath, s3Key, options) {
+        callCount++;
+        if (callCount === 2) {
+          // Delete the temp file to cause an error
+          await fs.unlink(tempFile).catch(() => {});
+        }
+        return originalUpload.call(this, localPath, s3Key, options);
+      });
+
+      await backupService.runBackup();
+
+      const backupRun = await db('backup_runs')
+        .orderBy('started_at', 'desc')
+        .first();
+
+      // Should complete despite one file error
+      expect(backupRun.status).toBe('completed');
+      expect(backupRun.files_backed_up).toBeGreaterThan(0);
+
+      // Restore original method
+      S3StorageAdapter.prototype.upload = originalUpload;
+    });
+
+    it('should retry failed uploads with exponential backoff', async () => {
+      if (process.env.SKIP_S3_TESTS === 'true') return;
+
+      // Mock S3 upload to fail twice then succeed
+      const originalUpload = S3StorageAdapter.prototype.upload;
+      let attemptCount = 0;
+      S3StorageAdapter.prototype.upload = jest.fn(async function(localPath, s3Key, options) {
+        attemptCount++;
+        if (attemptCount <= 2) {
+          const error = new Error('Network timeout');
+          error.code = 'ETIMEDOUT';
+          throw error;
+        }
+        return originalUpload.call(this, localPath, s3Key, options);
+      });
+
+      await backupService.runBackup();
+
+      const backupRun = await db('backup_runs')
+        .orderBy('started_at', 'desc')
+        .first();
+
+      // Should succeed after retries
+      expect(backupRun.status).toBe('completed');
+      expect(attemptCount).toBeGreaterThan(2);
+
+      // Restore original method
+      S3StorageAdapter.prototype.upload = originalUpload;
+    });
+  });
+
+  // Helper functions
+
+  async function setupTestData() {
+    // Create test directory structure
+    const dirs = [
+      'events/active/event1',
+      'events/active/event2',
+      'events/archived',
+      'thumbnails',
+      'uploads'
+    ];
+
+    for (const dir of dirs) {
+      await fs.mkdir(path.join(testStoragePath, dir), { recursive: true });
+    }
+
+    // Create test files
+    const files = [
+      { path: 'events/active/event1/photo1.jpg', content: 'photo1 content' },
+      { path: 'events/active/event1/photo2.jpg', content: 'photo2 content' },
+      { path: 'events/active/event2/photo3.jpg', content: 'photo3 content' },
+      { path: 'events/archived/old-event.zip', content: 'archived content' },
+      { path: 'thumbnails/thumb1.jpg', content: 'thumbnail content' },
+      { path: 'uploads/logo.png', content: 'logo content' }
+    ];
+
+    for (const file of files) {
+      await fs.writeFile(
+        path.join(testStoragePath, file.path),
+        file.content
+      );
+    }
+  }
+
+  async function configureS3Backup() {
+    const settings = [
+      { setting_key: 'backup_enabled', setting_value: 'true' },
+      { setting_key: 'backup_destination_type', setting_value: '"s3"' },
+      { setting_key: 'backup_s3_bucket', setting_value: `"${TEST_CONFIG.bucket}"` },
+      { setting_key: 'backup_s3_region', setting_value: `"${TEST_CONFIG.region}"` },
+      { setting_key: 'backup_s3_endpoint', setting_value: `"${TEST_CONFIG.endpoint}"` },
+      { setting_key: 'backup_s3_access_key', setting_value: `"${TEST_CONFIG.accessKeyId}"` },
+      { setting_key: 'backup_s3_secret_key', setting_value: `"${TEST_CONFIG.secretAccessKey}"` },
+      { setting_key: 'backup_s3_force_path_style', setting_value: 'true' },
+      { setting_key: 'backup_s3_ssl_enabled', setting_value: 'false' },
+      { setting_key: 'backup_include_archived', setting_value: 'true' },
+      { setting_key: 'backup_incremental', setting_value: 'true' },
+      { setting_key: 'backup_max_file_size_mb', setting_value: '100' }
+    ];
+
+    for (const setting of settings) {
+      await db('app_settings')
+        .insert({
+          setting_type: 'backup',
+          ...setting,
+          created_at: new Date(),
+          updated_at: new Date()
+        })
+        .onConflict(['setting_type', 'setting_key'])
+        .merge();
+    }
+  }
+
+  async function listS3Objects() {
+    const response = await s3Client.send(new ListObjectsV2Command({
+      Bucket: TEST_CONFIG.bucket
+    }));
+    return response.Contents || [];
+  }
+
+  async function cleanupS3Bucket() {
+    try {
+      const objects = await listS3Objects();
+      if (objects.length > 0) {
+        await s3Client.send(new DeleteObjectsCommand({
+          Bucket: TEST_CONFIG.bucket,
+          Delete: {
+            Objects: objects.map(obj => ({ Key: obj.Key }))
+          }
+        }));
+      }
+    } catch (error) {
+      console.error('Failed to cleanup S3 objects:', error);
+    }
+  }
+});

backend/__tests__/services/backupService.enhanced.test.js

@@ -0,0 +1,751 @@
+const { describe, it, expect, jest, beforeEach, afterEach } = require('@jest/globals');
+const mockFs = require('mock-fs');
+const path = require('path');
+const crypto = require('crypto');
+const { EventEmitter } = require('events');
+
+// Mock dependencies before requiring the module
+jest.mock('../../src/database/db');
+jest.mock('../../src/utils/logger');
+jest.mock('../../src/services/emailProcessor');
+jest.mock('node-cron');
+jest.mock('../../src/services/backupManifest');
+jest.mock('../../src/services/storage/s3Storage');
+
+const backupService = require('../../src/services/backupService');
+const { db } = require('../../src/database/db');
+const logger = require('../../src/utils/logger');
+const { queueEmail } = require('../../src/services/emailProcessor');
+const cron = require('node-cron');
+const backupManifest = require('../../src/services/backupManifest');
+const S3StorageAdapter = require('../../src/services/storage/s3Storage');
+
+describe('Enhanced Backup Service Tests', () => {
+  let mockDb;
+  let mockS3Client;
+  let mockCronJob;
+
+  beforeEach(() => {
+    // Reset all mocks
+    jest.clearAllMocks();
+    
+    // Mock database
+    mockDb = {
+      select: jest.fn().mockReturnThis(),
+      where: jest.fn().mockReturnThis(),
+      orderBy: jest.fn().mockReturnThis(),
+      limit: jest.fn().mockReturnThis(),
+      first: jest.fn(),
+      insert: jest.fn(),
+      update: jest.fn(),
+      delete: jest.fn()
+    };
+    db.mockReturnValue(mockDb);
+    
+    // Mock cron job
+    mockCronJob = {
+      stop: jest.fn()
+    };
+    cron.schedule.mockReturnValue(mockCronJob);
+    
+    // Mock S3 client
+    mockS3Client = {
+      testConnection: jest.fn().mockResolvedValue(true),
+      upload: jest.fn().mockResolvedValue({ Location: 's3://bucket/key' }),
+      uploadStream: jest.fn().mockResolvedValue({ Location: 's3://bucket/key' }),
+      download: jest.fn().mockResolvedValue(),
+      exists: jest.fn().mockResolvedValue(false),
+      delete: jest.fn().mockResolvedValue(),
+      list: jest.fn().mockResolvedValue({ Contents: [] })
+    };
+    S3StorageAdapter.mockImplementation(() => mockS3Client);
+    
+    // Mock backup manifest
+    backupManifest.generateManifest = jest.fn().mockResolvedValue({
+      backup: { id: 'test-backup-123' },
+      version: '2.0'
+    });
+    backupManifest.saveManifest = jest.fn().mockResolvedValue('/path/to/manifest.json');
+    backupManifest.loadManifest = jest.fn().mockResolvedValue({});
+    backupManifest.validateManifest = jest.fn();
+    backupManifest.generateSummaryReport = jest.fn().mockReturnValue('Summary report');
+    
+    // Mock logger
+    logger.info = jest.fn();
+    logger.error = jest.fn();
+    logger.warn = jest.fn();
+    logger.debug = jest.fn();
+  });
+
+  afterEach(() => {
+    mockFs.restore();
+  });
+
+  describe('getBackupConfig', () => {
+    it('should retrieve and parse backup configuration from database', async () => {
+      const mockSettings = [
+        { setting_key: 'backup_enabled', setting_value: 'true' },
+        { setting_key: 'backup_destination_type', setting_value: '"s3"' },
+        { setting_key: 'backup_s3_bucket', setting_value: '"test-bucket"' },
+        { setting_key: 'backup_retention_days', setting_value: '30' }
+      ];
+      
+      mockDb.select.mockResolvedValue(mockSettings);
+      
+      const config = await backupService.getBackupConfig();
+      
+      expect(config).toEqual({
+        backup_enabled: true,
+        backup_destination_type: 's3',
+        backup_s3_bucket: 'test-bucket',
+        backup_retention_days: 30
+      });
+      
+      expect(db).toHaveBeenCalledWith('app_settings');
+      expect(mockDb.where).toHaveBeenCalledWith('setting_type', 'backup');
+    });
+
+    it('should handle JSON parse errors gracefully', async () => {
+      const mockSettings = [
+        { setting_key: 'backup_enabled', setting_value: 'invalid-json' }
+      ];
+      
+      mockDb.select.mockResolvedValue(mockSettings);
+      
+      const config = await backupService.getBackupConfig();
+      
+      expect(config).toEqual({
+        backup_enabled: 'invalid-json'
+      });
+    });
+
+    it('should return null on database error', async () => {
+      mockDb.select.mockRejectedValue(new Error('Database error'));
+      
+      const config = await backupService.getBackupConfig();
+      
+      expect(config).toBeNull();
+      expect(logger.error).toHaveBeenCalled();
+    });
+  });
+
+  describe('S3 Backup Functionality', () => {
+    beforeEach(() => {
+      // Mock file system
+      mockFs({
+        '/storage/events/active/event1': {
+          'photo1.jpg': Buffer.from('photo1 content'),
+          'photo2.jpg': Buffer.from('photo2 content')
+        },
+        '/storage/events/archived/event2.zip': Buffer.from('archived content'),
+        '/storage/thumbnails': {
+          'thumb1.jpg': Buffer.from('thumb1 content')
+        },
+        '/storage/uploads': {
+          'logo.png': Buffer.from('logo content')
+        }
+      });
+      
+      process.env.STORAGE_PATH = '/storage';
+    });
+
+    it('should perform S3 backup with correct configuration', async () => {
+      const config = {
+        backup_enabled: true,
+        backup_destination_type: 's3',
+        backup_s3_bucket: 'test-bucket',
+        backup_s3_region: 'us-east-1',
+        backup_s3_endpoint: 'https://s3.amazonaws.com',
+        backup_s3_access_key: 'test-key',
+        backup_s3_secret_key: 'test-secret',
+        backup_include_archived: true,
+        backup_max_file_size_mb: 100
+      };
+      
+      mockDb.select.mockResolvedValue([]);
+      mockDb.where.mockReturnThis();
+      mockDb.first.mockResolvedValue(null);
+      mockDb.insert.mockResolvedValue([1]);
+      
+      jest.spyOn(backupService, 'getBackupConfig').mockResolvedValue(config);
+      jest.spyOn(backupService, 'getDatabaseBackupInfo').mockResolvedValue({
+        type: 'sqlite',
+        backupFile: null,
+        hasChanged: true
+      });
+      
+      await backupService.runBackup();
+      
+      expect(S3StorageAdapter).toHaveBeenCalledWith({
+        bucket: 'test-bucket',
+        region: 'us-east-1',
+        endpoint: 'https://s3.amazonaws.com',
+        accessKeyId: 'test-key',
+        secretAccessKey: 'test-secret',
+        forcePathStyle: false,
+        sslEnabled: true,
+        maxRetries: 3,
+        retryDelay: 1000
+      });
+      
+      expect(mockS3Client.testConnection).toHaveBeenCalled();
+      expect(mockS3Client.upload).toHaveBeenCalled();
+    });
+
+    it('should handle S3 upload failures gracefully', async () => {
+      const config = {
+        backup_enabled: true,
+        backup_destination_type: 's3',
+        backup_s3_bucket: 'test-bucket',
+        backup_s3_access_key: 'test-key',
+        backup_s3_secret_key: 'test-secret'
+      };
+      
+      mockDb.select.mockResolvedValue([]);
+      mockDb.insert.mockResolvedValue([1]);
+      mockDb.first.mockResolvedValue(null);
+      
+      jest.spyOn(backupService, 'getBackupConfig').mockResolvedValue(config);
+      
+      mockS3Client.testConnection.mockRejectedValue(new Error('Connection failed'));
+      
+      await backupService.runBackup();
+      
+      expect(logger.error).toHaveBeenCalledWith('S3 backup failed:', expect.any(Error));
+      expect(mockDb.update).toHaveBeenCalledWith(expect.objectContaining({
+        status: 'failed',
+        error_message: expect.stringContaining('Connection failed')
+      }));
+    });
+
+    it('should skip unchanged files in incremental backup', async () => {
+      const config = {
+        backup_enabled: true,
+        backup_destination_type: 's3',
+        backup_s3_bucket: 'test-bucket',
+        backup_s3_access_key: 'test-key',
+        backup_s3_secret_key: 'test-secret',
+        backup_incremental: true
+      };
+      
+      // Mock existing file state
+      mockDb.first.mockImplementation((query) => {
+        if (query === undefined) {
+          return Promise.resolve({
+            file_path: 'events/active/event1/photo1.jpg',
+            checksum: crypto.createHash('sha256').update('photo1 content').digest('hex')
+          });
+        }
+        return Promise.resolve(null);
+      });
+      
+      mockDb.select.mockResolvedValue([]);
+      mockDb.insert.mockResolvedValue([1]);
+      
+      jest.spyOn(backupService, 'getBackupConfig').mockResolvedValue(config);
+      
+      await backupService.runBackup();
+      
+      // Should skip unchanged file
+      const uploadCalls = mockS3Client.upload.mock.calls;
+      const photo1Uploaded = uploadCalls.some(call => 
+        call[1].includes('photo1.jpg')
+      );
+      expect(photo1Uploaded).toBe(false);
+    });
+
+    it('should include database backup when configured', async () => {
+      const config = {
+        backup_enabled: true,
+        backup_destination_type: 's3',
+        backup_s3_bucket: 'test-bucket',
+        backup_s3_access_key: 'test-key',
+        backup_s3_secret_key: 'test-secret',
+        backup_include_database: true
+      };
+      
+      mockDb.select.mockResolvedValue([]);
+      mockDb.insert.mockResolvedValue([1]);
+      
+      jest.spyOn(backupService, 'getBackupConfig').mockResolvedValue(config);
+      jest.spyOn(backupService, 'getDatabaseBackupInfo').mockResolvedValue({
+        type: 'sqlite',
+        backupFile: '/backup/db-backup.sql',
+        size: 1024000,
+        checksum: 'abc123',
+        hasChanged: false
+      });
+      
+      // Mock database backup file
+      mockFs({
+        '/storage/events/active': {},
+        '/backup/db-backup.sql': Buffer.from('database backup content')
+      });
+      
+      await backupService.runBackup();
+      
+      // Verify database backup was uploaded
+      const uploadCalls = mockS3Client.upload.mock.calls;
+      const dbBackupUploaded = uploadCalls.some(call => 
+        call[1].includes('database/db-backup.sql')
+      );
+      expect(dbBackupUploaded).toBe(true);
+    });
+
+    it('should validate required S3 configuration', async () => {
+      const config = {
+        backup_enabled: true,
+        backup_destination_type: 's3',
+        backup_s3_bucket: 'test-bucket'
+        // Missing access key and secret key
+      };
+      
+      mockDb.select.mockResolvedValue([]);
+      mockDb.insert.mockResolvedValue([1]);
+      
+      jest.spyOn(backupService, 'getBackupConfig').mockResolvedValue(config);
+      
+      await backupService.runBackup();
+      
+      expect(logger.error).toHaveBeenCalledWith(
+        'S3 backup failed:',
+        expect.objectContaining({
+          message: expect.stringContaining('S3 backup configuration incomplete')
+        })
+      );
+    });
+  });
+
+  describe('Manifest Generation', () => {
+    it('should generate and save manifest for successful backup', async () => {
+      const config = {
+        backup_enabled: true,
+        backup_destination_type: 'local',
+        backup_destination_path: '/backup',
+        backup_manifest_format: 'json'
+      };
+      
+      mockDb.select.mockResolvedValue([]);
+      mockDb.insert.mockResolvedValue([1]);
+      mockDb.first.mockResolvedValue(null);
+      
+      jest.spyOn(backupService, 'getBackupConfig').mockResolvedValue(config);
+      
+      mockFs({
+        '/storage/events/active/event1': {
+          'photo1.jpg': Buffer.from('photo1 content')
+        },
+        '/backup': {}
+      });
+      
+      await backupService.runBackup();
+      
+      expect(backupManifest.generateManifest).toHaveBeenCalledWith(
+        expect.objectContaining({
+          backupType: 'full',
+          backupPath: '/backup',
+          format: 'json'
+        })
+      );
+      
+      expect(backupManifest.saveManifest).toHaveBeenCalled();
+    });
+
+    it('should generate incremental manifest when parent exists', async () => {
+      const config = {
+        backup_enabled: true,
+        backup_destination_type: 'local',
+        backup_destination_path: '/backup'
+      };
+      
+      const lastBackup = {
+        id: 1,
+        manifest_path: '/backup/manifests/previous.json',
+        manifest_id: 'previous-backup-123'
+      };
+      
+      mockDb.select.mockResolvedValue([]);
+      mockDb.insert.mockResolvedValue([2]);
+      mockDb.first.mockImplementation(() => Promise.resolve(lastBackup));
+      mockDb.orderBy.mockReturnThis();
+      mockDb.where.mockReturnThis();
+      mockDb.whereNot = jest.fn().mockReturnThis();
+      
+      jest.spyOn(backupService, 'getBackupConfig').mockResolvedValue(config);
+      
+      mockFs({
+        '/storage/events/active': {},
+        '/backup': {}
+      });
+      
+      await backupService.runBackup();
+      
+      expect(backupManifest.loadManifest).toHaveBeenCalledWith('/backup/manifests/previous.json');
+      expect(backupManifest.generateIncrementalManifest).toHaveBeenCalled();
+    });
+
+    it('should upload manifest to S3 for S3 backups', async () => {
+      const config = {
+        backup_enabled: true,
+        backup_destination_type: 's3',
+        backup_s3_bucket: 'test-bucket',
+        backup_s3_access_key: 'test-key',
+        backup_s3_secret_key: 'test-secret',
+        backup_manifest_format: 'yaml'
+      };
+      
+      mockDb.select.mockResolvedValue([]);
+      mockDb.insert.mockResolvedValue([1]);
+      mockDb.first.mockResolvedValue(null);
+      
+      jest.spyOn(backupService, 'getBackupConfig').mockResolvedValue(config);
+      
+      const manifest = {
+        backup: { id: 'backup-123' },
+        version: '2.0'
+      };
+      backupManifest.generateManifest.mockResolvedValue(manifest);
+      
+      mockFs({
+        '/storage/events/active': {},
+        '/storage/temp': {}
+      });
+      
+      await backupService.runBackup();
+      
+      // Verify manifest was uploaded to S3
+      const uploadCalls = mockS3Client.upload.mock.calls;
+      const manifestUploaded = uploadCalls.some(call => 
+        call[1].includes('manifests/backup-manifest-backup-123.yaml')
+      );
+      expect(manifestUploaded).toBe(true);
+    });
+  });
+
+  describe('Backward Compatibility', () => {
+    it('should support local backup destination', async () => {
+      const config = {
+        backup_enabled: true,
+        backup_destination_type: 'local',
+        backup_destination_path: '/backup/local'
+      };
+      
+      mockDb.select.mockResolvedValue([]);
+      mockDb.insert.mockResolvedValue([1]);
+      mockDb.first.mockResolvedValue(null);
+      
+      jest.spyOn(backupService, 'getBackupConfig').mockResolvedValue(config);
+      
+      mockFs({
+        '/storage/events/active/event1': {
+          'photo1.jpg': Buffer.from('photo1 content')
+        },
+        '/backup/local': {}
+      });
+      
+      await backupService.runBackup();
+      
+      // Verify files were copied to local destination
+      const fs = require('fs');
+      const destPath = '/backup/local/events/active/event1/photo1.jpg';
+      expect(fs.existsSync(destPath)).toBe(true);
+    });
+
+    it('should support rsync backup destination', async () => {
+      const config = {
+        backup_enabled: true,
+        backup_destination_type: 'rsync',
+        backup_rsync_host: 'backup.example.com',
+        backup_rsync_user: 'backup',
+        backup_rsync_path: '/remote/backup'
+      };
+      
+      mockDb.select.mockResolvedValue([]);
+      mockDb.insert.mockResolvedValue([1]);
+      mockDb.first.mockResolvedValue(null);
+      
+      jest.spyOn(backupService, 'getBackupConfig').mockResolvedValue(config);
+      
+      // Mock exec for rsync
+      const { exec } = require('child_process');
+      const mockExec = jest.fn((cmd, callback) => {
+        callback(null, { stdout: 'Number of files transferred: 1\nTotal file size: 1024 bytes' });
+      });
+      exec.mockImplementation(mockExec);
+      
+      mockFs({
+        '/storage/events/active': {}
+      });
+      
+      await backupService.runBackup();
+      
+      expect(mockExec).toHaveBeenCalledWith(
+        expect.stringContaining('rsync'),
+        expect.any(Function)
+      );
+    });
+  });
+
+  describe('Error Handling and Recovery', () => {
+    it('should handle file read errors gracefully', async () => {
+      const config = {
+        backup_enabled: true,
+        backup_destination_type: 's3',
+        backup_s3_bucket: 'test-bucket',
+        backup_s3_access_key: 'test-key',
+        backup_s3_secret_key: 'test-secret'
+      };
+      
+      mockDb.select.mockResolvedValue([]);
+      mockDb.insert.mockResolvedValue([1]);
+      mockDb.first.mockResolvedValue(null);
+      
+      jest.spyOn(backupService, 'getBackupConfig').mockResolvedValue(config);
+      
+      // Mock file that throws error on read
+      const fs = require('fs');
+      const originalCreateReadStream = fs.createReadStream;
+      fs.createReadStream = jest.fn((path) => {
+        if (path.includes('error.jpg')) {
+          const stream = new EventEmitter();
+          process.nextTick(() => stream.emit('error', new Error('File read error')));
+          return stream;
+        }
+        return originalCreateReadStream(path);
+      });
+      
+      mockFs({
+        '/storage/events/active': {
+          'error.jpg': Buffer.from('content'),
+          'good.jpg': Buffer.from('content')
+        }
+      });
+      
+      await backupService.runBackup();
+      
+      // Should continue with other files despite error
+      expect(logger.error).toHaveBeenCalledWith(
+        expect.stringContaining('Failed to backup file'),
+        expect.any(Error)
+      );
+      
+      fs.createReadStream = originalCreateReadStream;
+    });
+
+    it('should send failure email on backup error', async () => {
+      const config = {
+        backup_enabled: true,
+        backup_destination_type: 's3',
+        backup_s3_bucket: 'test-bucket',
+        backup_email_on_failure: true
+      };
+      
+      const admins = [
+        { email: 'admin1@example.com', is_active: true },
+        { email: 'admin2@example.com', is_active: true }
+      ];
+      
+      mockDb.select.mockResolvedValue([]);
+      mockDb.insert.mockResolvedValue([1]);
+      mockDb.where.mockReturnThis();
+      
+      jest.spyOn(backupService, 'getBackupConfig')
+        .mockResolvedValueOnce(config)
+        .mockResolvedValueOnce(config);
+      
+      // Force an error
+      jest.spyOn(backupService, 'getFilesToBackup').mockRejectedValue(new Error('Storage error'));
+      
+      // Mock admin users query
+      db.mockImplementation((table) => {
+        if (table === 'admin_users') {
+          return {
+            where: jest.fn().mockResolvedValue(admins)
+          };
+        }
+        return mockDb;
+      });
+      
+      await backupService.runBackup();
+      
+      expect(queueEmail).toHaveBeenCalledTimes(2);
+      expect(queueEmail).toHaveBeenCalledWith(
+        null,
+        'admin1@example.com',
+        'backup_failed',
+        expect.objectContaining({
+          error_message: 'Storage error'
+        })
+      );
+    });
+
+    it('should handle concurrent backup attempts', async () => {
+      const config = {
+        backup_enabled: true,
+        backup_destination_type: 'local',
+        backup_destination_path: '/backup'
+      };
+      
+      jest.spyOn(backupService, 'getBackupConfig').mockResolvedValue(config);
+      
+      mockFs({
+        '/storage/events/active': {},
+        '/backup': {}
+      });
+      
+      // Start two backups concurrently
+      const backup1 = backupService.runBackup();
+      const backup2 = backupService.runBackup();
+      
+      await Promise.all([backup1, backup2]);
+      
+      // Second backup should be skipped
+      expect(logger.warn).toHaveBeenCalledWith('Backup already running, skipping');
+    });
+  });
+
+  describe('Service Lifecycle', () => {
+    it('should start backup service with cron schedule', async () => {
+      const config = {
+        backup_enabled: true,
+        backup_schedule: '0 3 * * *' // 3 AM daily
+      };
+      
+      mockDb.select.mockResolvedValue(
+        Object.entries(config).map(([key, value]) => ({
+          setting_key: key,
+          setting_value: value.toString()
+        }))
+      );
+      
+      await backupService.startBackupService();
+      
+      expect(cron.schedule).toHaveBeenCalledWith('0 3 * * *', expect.any(Function));
+      expect(logger.info).toHaveBeenCalledWith('Backup service started with schedule: 0 3 * * *');
+    });
+
+    it('should stop existing job when restarting service', async () => {
+      const config = {
+        backup_enabled: true,
+        backup_schedule: '0 2 * * *'
+      };
+      
+      mockDb.select.mockResolvedValue(
+        Object.entries(config).map(([key, value]) => ({
+          setting_key: key,
+          setting_value: value.toString()
+        }))
+      );
+      
+      // Start service twice
+      await backupService.startBackupService();
+      await backupService.startBackupService();
+      
+      expect(mockCronJob.stop).toHaveBeenCalled();
+    });
+
+    it('should not start service when backup is disabled', async () => {
+      const config = {
+        backup_enabled: false
+      };
+      
+      mockDb.select.mockResolvedValue([
+        { setting_key: 'backup_enabled', setting_value: 'false' }
+      ]);
+      
+      await backupService.startBackupService();
+      
+      expect(cron.schedule).not.toHaveBeenCalled();
+      expect(logger.info).toHaveBeenCalledWith('Backup service is disabled');
+    });
+  });
+
+  describe('Backup Status and History', () => {
+    it('should return backup status with recent runs', async () => {
+      const recentRuns = [
+        {
+          id: 1,
+          started_at: new Date(),
+          completed_at: new Date(),
+          status: 'completed',
+          files_backed_up: 100,
+          total_size_bytes: 1024000,
+          manifest_path: '/backup/manifest.json'
+        }
+      ];
+      
+      mockDb.limit.mockResolvedValue(recentRuns);
+      
+      backupManifest.validateManifest.mockImplementation(() => true);
+      
+      const status = await backupService.getBackupStatus();
+      
+      expect(status).toEqual({
+        isRunning: false,
+        isHealthy: true,
+        lastRun: expect.objectContaining({
+          ...recentRuns[0],
+          manifestValid: true
+        }),
+        recentRuns: recentRuns,
+        nextScheduledRun: expect.any(String)
+      });
+    });
+
+    it('should clean up old backup runs', async () => {
+      mockDb.delete.mockResolvedValue(5);
+      
+      await backupService.cleanupOldBackupRuns(30);
+      
+      expect(mockDb.where).toHaveBeenCalledWith('started_at', '<', expect.any(Date));
+      expect(mockDb.delete).toHaveBeenCalled();
+      expect(logger.info).toHaveBeenCalledWith('Cleaned up 5 old backup runs');
+    });
+  });
+
+  describe('getBackupManifest', () => {
+    it('should retrieve manifest from local filesystem', async () => {
+      const backupRun = {
+        id: 1,
+        manifest_path: '/backup/manifests/backup-123.json'
+      };
+      
+      mockDb.first.mockResolvedValue(backupRun);
+      
+      const manifest = { backup: { id: 'backup-123' } };
+      backupManifest.loadManifest.mockResolvedValue(manifest);
+      backupManifest.generateSummaryReport.mockReturnValue('Summary');
+      
+      const result = await backupService.getBackupManifest(1);
+      
+      expect(result).toEqual({
+        manifest: manifest,
+        summary: 'Summary'
+      });
+    });
+
+    it('should retrieve manifest from S3', async () => {
+      const backupRun = {
+        id: 1,
+        manifest_path: 's3://test-bucket/backups/manifests/backup-123.json'
+      };
+      
+      mockDb.first.mockResolvedValue(backupRun);
+      mockDb.select.mockResolvedValue([
+        { setting_key: 'backup_s3_access_key', setting_value: '"test-key"' },
+        { setting_key: 'backup_s3_secret_key', setting_value: '"test-secret"' }
+      ]);
+      
+      const manifest = { backup: { id: 'backup-123' } };
+      backupManifest.loadManifest.mockResolvedValue(manifest);
+      
+      await backupService.getBackupManifest(1);
+      
+      expect(S3StorageAdapter).toHaveBeenCalled();
+      expect(mockS3Client.download).toHaveBeenCalledWith(
+        'backups/manifests/backup-123.json',
+        expect.any(String)
+      );
+    });
+  });
+});

backend/knexfile.js

@@ -26,29 +26,37 @@ const config = {
 
   production: {
     client: process.env.DATABASE_CLIENT || 'pg',
-    connection: {
-      host: process.env.DB_HOST || 'db',
-      port: process.env.DB_PORT || 5432,
-      user: process.env.DB_USER || 'picpeak',
-      password: process.env.DB_PASSWORD,
-      database: process.env.DB_NAME || 'picpeak',
-      ssl: process.env.DB_SSL === 'true' ? { rejectUnauthorized: false } : false,
-      // Connection stability settings
-      connectionTimeoutMillis: 30000,
-      idleTimeoutMillis: 30000,
-      keepAlive: true,
-      keepAliveInitialDelayMillis: 0
-    },
-    pool: {
-      min: 2,
-      max: 10,
-      acquireTimeoutMillis: 30000,
-      createTimeoutMillis: 30000,
-      idleTimeoutMillis: 30000,
-      reapIntervalMillis: 1000,
-      createRetryIntervalMillis: 200,
-      propagateCreateError: false
-    },
+    // Support both Postgres and SQLite in production based on DATABASE_CLIENT
+    connection: (process.env.DATABASE_CLIENT || 'pg') === 'pg'
+      ? {
+          host: process.env.DB_HOST || 'db',
+          port: process.env.DB_PORT || 5432,
+          user: process.env.DB_USER || 'picpeak',
+          password: process.env.DB_PASSWORD,
+          database: process.env.DB_NAME || 'picpeak',
+          ssl: process.env.DB_SSL === 'true' ? { rejectUnauthorized: false } : false,
+          // Connection stability settings
+          connectionTimeoutMillis: 30000,
+          idleTimeoutMillis: 30000,
+          keepAlive: true,
+          keepAliveInitialDelayMillis: 0
+        }
+      : {
+          filename: path.join(__dirname, process.env.DATABASE_PATH || './data/photo_sharing.db')
+        },
+    useNullAsDefault: (process.env.DATABASE_CLIENT || 'pg') !== 'pg',
+    pool: (process.env.DATABASE_CLIENT || 'pg') === 'pg'
+      ? {
+          min: 5,
+          max: 25,
+          acquireTimeoutMillis: 60000,
+          createTimeoutMillis: 60000,
+          idleTimeoutMillis: 30000,
+          reapIntervalMillis: 1000,
+          createRetryIntervalMillis: 200,
+          propagateCreateError: false
+        }
+      : undefined,
     migrations: {
       directory: './migrations'
     },
@@ -56,4 +64,4 @@ const config = {
   }
 };
 
-module.exports = config[process.env.NODE_ENV || 'development'];
+module.exports = config[process.env.NODE_ENV || 'development'];

backend/migrations/004_add_categories_and_cms.js

@@ -1,101 +0,0 @@
-const { db } = require('../src/database/db');
-
-async function up() {
-  console.log('Adding photo categories and CMS tables...');
-  
-  // Create photo_categories table
-  await db.schema.createTable('photo_categories', (table) => {
-    table.increments('id').primary();
-    table.string('name', 100).notNullable();
-    table.string('slug', 100).notNullable();
-    table.boolean('is_global').defaultTo(true);
-    table.integer('event_id').references('id').inTable('events').onDelete('CASCADE');
-    table.timestamp('created_at').defaultTo(db.fn.now());
-    
-    // Unique constraint for slug within event scope
-    table.unique(['slug', 'event_id']);
-  });
-
-  // Create cms_pages table
-  await db.schema.createTable('cms_pages', (table) => {
-    table.increments('id').primary();
-    table.string('slug', 100).unique().notNullable();
-    table.text('title_en');
-    table.text('title_de');
-    table.text('content_en');
-    table.text('content_de');
-    table.timestamp('updated_at').defaultTo(db.fn.now());
-  });
-
-  // Add category_id to photos table
-  await db.schema.alterTable('photos', (table) => {
-    table.integer('category_id').references('id').inTable('photo_categories');
-  });
-
-  // Add language preference to admin_users
-  await db.schema.alterTable('admin_users', (table) => {
-    table.string('language', 2).defaultTo('en');
-  });
-
-  // Add language preference to app_settings for global default
-  await db('app_settings').insert({
-    setting_key: 'default_language',
-    setting_value: 'en',
-    setting_type: 'general',
-    updated_at: new Date()
-  });
-
-  // Insert default global categories
-  const defaultCategories = [
-    { name: 'Ceremony', slug: 'ceremony', is_global: true },
-    { name: 'Reception', slug: 'reception', is_global: true },
-    { name: 'Portraits', slug: 'portraits', is_global: true },
-    { name: 'Group Photos', slug: 'group-photos', is_global: true },
-    { name: 'Details', slug: 'details', is_global: true },
-    { name: 'Party', slug: 'party', is_global: true }
-  ];
-
-  await db('photo_categories').insert(defaultCategories);
-
-  // Insert default legal pages
-  await db('cms_pages').insert([
-    {
-      slug: 'impressum',
-      title_en: 'Legal Notice',
-      title_de: 'Impressum',
-      content_en: '<h2>Legal Notice</h2><p>Please edit this content in the admin panel.</p>',
-      content_de: '<h2>Impressum</h2><p>Bitte bearbeiten Sie diesen Inhalt im Admin-Panel.</p>',
-      updated_at: new Date()
-    },
-    {
-      slug: 'datenschutz',
-      title_en: 'Privacy Policy',
-      title_de: 'Datenschutzerklärung',
-      content_en: '<h2>Privacy Policy</h2><p>Please edit this content in the admin panel.</p>',
-      content_de: '<h2>Datenschutzerklärung</h2><p>Bitte bearbeiten Sie diesen Inhalt im Admin-Panel.</p>',
-      updated_at: new Date()
-    }
-  ]);
-
-  console.log('Photo categories and CMS tables created successfully');
-}
-
-async function down() {
-  // Remove language from app_settings
-  await db('app_settings').where('setting_key', 'default_language').delete();
-  
-  // Drop columns
-  await db.schema.alterTable('admin_users', (table) => {
-    table.dropColumn('language');
-  });
-  
-  await db.schema.alterTable('photos', (table) => {
-    table.dropColumn('category_id');
-  });
-  
-  // Drop tables
-  await db.schema.dropTableIfExists('cms_pages');
-  await db.schema.dropTableIfExists('photo_categories');
-}
-
-module.exports = { up, down };

backend/migrations/015_add_login_attempts_table.js

@@ -1,19 +0,0 @@
-exports.up = function(knex) {
-  return knex.schema.createTable('login_attempts', table => {
-    table.increments('id').primary();
-    table.string('identifier').notNullable(); // username or email
-    table.string('ip_address', 45).notNullable(); // IPv4 or IPv6
-    table.text('user_agent');
-    table.timestamp('attempt_time').defaultTo(knex.fn.now());
-    table.boolean('success').defaultTo(false);
-    
-    // Indexes for performance
-    table.index('identifier');
-    table.index('attempt_time');
-    table.index(['identifier', 'success', 'attempt_time']);
-  });
-};
-
-exports.down = function(knex) {
-  return knex.schema.dropTableIfExists('login_attempts');
-};

backend/migrations/016_add_auth_security_columns.js

@@ -1,25 +0,0 @@
-exports.up = function(knex) {
-  return knex.schema.table('admin_users', table => {
-    // Add password change tracking
-    table.timestamp('password_changed_at').nullable();
-    
-    // Add last login IP for security monitoring
-    table.string('last_login_ip', 45).nullable();
-    
-    // Add account security flags
-    table.boolean('two_factor_enabled').defaultTo(false);
-    table.string('two_factor_secret').nullable();
-    
-    // Add index for performance
-    table.index('password_changed_at');
-  });
-};
-
-exports.down = function(knex) {
-  return knex.schema.table('admin_users', table => {
-    table.dropColumn('password_changed_at');
-    table.dropColumn('last_login_ip');
-    table.dropColumn('two_factor_enabled');
-    table.dropColumn('two_factor_secret');
-  });
-};

backend/migrations/017_add_token_revocation_tables.js

@@ -1,34 +0,0 @@
-exports.up = function(knex) {
-  return knex.schema
-    // Table for individual token revocations
-    .createTable('revoked_tokens', table => {
-      table.increments('id').primary();
-      table.string('token_id').notNullable().unique(); // JWT ID or generated ID
-      table.integer('user_id').nullable(); // User who owned the token
-      table.string('token_type', 20); // admin, gallery, etc.
-      table.timestamp('revoked_at').defaultTo(knex.fn.now());
-      table.timestamp('expires_at').notNullable(); // When token would have expired
-      table.string('reason', 100); // password_change, logout, compromised, etc.
-      table.text('metadata'); // Additional JSON data
-      
-      // Indexes for performance
-      table.index('token_id');
-      table.index('user_id');
-      table.index('expires_at'); // For cleanup
-    })
-    // Table for user-level revocations (revoke all tokens before a certain time)
-    .createTable('user_token_revocations', table => {
-      table.integer('user_id').primary();
-      table.timestamp('revoked_at').notNullable();
-      table.string('reason', 100);
-      
-      // Index for quick lookups
-      table.index('revoked_at');
-    });
-};
-
-exports.down = function(knex) {
-  return knex.schema
-    .dropTableIfExists('user_token_revocations')
-    .dropTableIfExists('revoked_tokens');
-};

backend/migrations/041_add_logo_customization_settings.js

@@ -0,0 +1,89 @@
+exports.up = async function(knex) {
+  console.log('Running migration: 041_add_logo_customization_settings');
+  
+  // Add default logo customization settings
+  const logoSettings = [
+    {
+      setting_key: 'branding_logo_size',
+      setting_value: JSON.stringify('medium'),
+      setting_type: 'branding',
+      description: 'Logo size: small, medium, large, xlarge, or custom',
+      created_at: new Date(),
+      updated_at: new Date()
+    },
+    {
+      setting_key: 'branding_logo_max_height',
+      setting_value: JSON.stringify(48),
+      setting_type: 'branding', 
+      description: 'Maximum logo height in pixels (used when size is custom)',
+      created_at: new Date(),
+      updated_at: new Date()
+    },
+    {
+      setting_key: 'branding_logo_position',
+      setting_value: JSON.stringify('left'),
+      setting_type: 'branding',
+      description: 'Logo position in header: left, center, right',
+      created_at: new Date(),
+      updated_at: new Date()
+    },
+    {
+      setting_key: 'branding_logo_display_header',
+      setting_value: JSON.stringify(true),
+      setting_type: 'branding',
+      description: 'Show logo in gallery header',
+      created_at: new Date(),
+      updated_at: new Date()
+    },
+    {
+      setting_key: 'branding_logo_display_hero',
+      setting_value: JSON.stringify(true),
+      setting_type: 'branding',
+      description: 'Show logo in hero section (for non-grid layouts)',
+      created_at: new Date(),
+      updated_at: new Date()
+    },
+    {
+      setting_key: 'branding_logo_display_mode',
+      setting_value: JSON.stringify('logo_and_text'),
+      setting_type: 'branding',
+      description: 'Display mode: logo_only, text_only, logo_and_text',
+      created_at: new Date(),
+      updated_at: new Date()
+    }
+  ];
+
+  // Insert settings that don't already exist
+  for (const setting of logoSettings) {
+    const exists = await knex('app_settings')
+      .where('setting_key', setting.setting_key)
+      .first();
+    
+    if (!exists) {
+      await knex('app_settings').insert(setting);
+      console.log(`Added setting: ${setting.setting_key}`);
+    } else {
+      console.log(`Setting already exists: ${setting.setting_key}`);
+    }
+  }
+
+  console.log('Migration 041_add_logo_customization_settings completed');
+};
+
+exports.down = async function(knex) {
+  console.log('Rolling back migration: 041_add_logo_customization_settings');
+  
+  // Remove the logo customization settings
+  await knex('app_settings')
+    .whereIn('setting_key', [
+      'branding_logo_size',
+      'branding_logo_max_height',
+      'branding_logo_position',
+      'branding_logo_display_header',
+      'branding_logo_display_hero',
+      'branding_logo_display_mode'
+    ])
+    .del();
+  
+  console.log('Rollback of 041_add_logo_customization_settings completed');
+};

backend/migrations/README.md

@@ -0,0 +1,46 @@
+# Database Migrations
+
+This directory contains database migrations for the Wedding Photo Sharing platform.
+
+## Directory Structure
+
+### `/core`
+Essential migrations that are always run for new deployments. These include:
+- `init.js` - Initial database schema creation
+- Backup service tables (029-035)
+- Gallery feedback tables (033)
+
+### `/legacy`
+Migrations needed only when upgrading from older versions. New deployments can skip these as the core schema already includes all necessary tables and columns.
+
+## For New Deployments
+
+If you're deploying this application for the first time:
+1. The `initializeDatabase()` function in `src/database/db.js` will create all necessary tables
+2. Only migrations in the `/core` directory will be run
+3. This ensures a clean, optimized database schema
+
+## For Existing Deployments
+
+If you're upgrading from an older version:
+1. All migrations (both core and legacy) will be run in sequence
+2. The migration system tracks which migrations have been applied
+3. Only new migrations will be executed
+
+## Running Migrations
+
+```bash
+# Development
+npm run migrate
+
+# Production
+npm run migrate:prod
+```
+
+## Note on Duplicate Migration Numbers
+
+The legacy directory contains renamed duplicates:
+- `014_add_host_name_to_events_duplicate.js` (was duplicate of 014)
+- `027_add_rate_limit_settings_duplicate.js` (was duplicate of 027)
+
+These have been renamed to avoid conflicts while preserving the migration history.

backend/migrations/core/001_init.js

@@ -1,33 +1,39 @@
 const bcrypt = require('bcrypt');
-const { db, initializeDatabase } = require('../src/database/db');
-const { generateReadablePassword } = require('../src/utils/passwordGenerator');
+const { initializeDatabase } = require('../../src/database/db');
+const { generateReadablePassword } = require('../../src/utils/passwordGenerator');
 const fs = require('fs').promises;
 const path = require('path');
 
-async function runMigrations() {
-  console.log('Running database migrations...');
+exports.up = async function(knex) {
+  console.log('Initializing database schema...');
   
   try {
     // Initialize tables
     await initializeDatabase();
     
     // Create default admin user if none exists
-    const adminExists = await db('admin_users').first();
+    const adminExists = await knex('admin_users').first();
     if (!adminExists) {
       // Generate a secure random password
       const generatedPassword = generateReadablePassword();
       const passwordHash = await bcrypt.hash(generatedPassword, 12); // Increased rounds for better security
       
-      await db('admin_users').insert({
-        username: 'admin',
-        email: 'admin@example.com',
+      // Get admin credentials from environment or use defaults
+      const adminUsername = process.env.ADMIN_USERNAME || 'admin';
+      const adminEmail = process.env.ADMIN_EMAIL || 'admin@example.com';
+      
+      await knex('admin_users').insert({
+        username: adminUsername,
+        email: adminEmail,
         password_hash: passwordHash,
-        must_change_password: true, // Flag for forcing password change
+        must_change_password: true,
         created_at: new Date()
       });
       
-      // Save the generated password to a file for the user to retrieve
-      const setupInfoPath = path.join(__dirname, '..', '..', 'ADMIN_CREDENTIALS.txt');
+      // Try to save credentials to file, but don't fail if we can't
+      const dataDir = path.join(__dirname, '..', '..', 'data');
+      const setupInfoPath = path.join(dataDir, 'ADMIN_CREDENTIALS.txt');
+      
       const setupInfo = `
 ========================================
 PicPeak Admin Credentials
@@ -35,39 +41,49 @@ PicPeak Admin Credentials
 
 Your admin account has been created with these credentials:
 
-Username: admin
+Email: ${adminEmail}
 Password: ${generatedPassword}
 
 IMPORTANT SECURITY NOTES:
-1. You MUST change this password on first login
+1. Please change this password after first login
 2. This file will be created only once
 3. Store these credentials securely
 4. Delete this file after noting the password
 
 Login URL: ${process.env.ADMIN_URL || 'http://localhost:3001'}/admin
 
+Login with the email address shown above
+
 Generated on: ${new Date().toISOString()}
 ========================================
 `;
       
-      await fs.writeFile(setupInfoPath, setupInfo, 'utf8');
+      try {
+        // Try to create directory and write file
+        await fs.mkdir(dataDir, { recursive: true });
+        await fs.writeFile(setupInfoPath, setupInfo, 'utf8');
+        console.log(`📁 Credentials also saved to: data/ADMIN_CREDENTIALS.txt`);
+      } catch (error) {
+        // If we can't write the file, that's okay - credentials are shown in console
+        console.log('⚠️  Could not save credentials to file (permission denied)');
+        console.log('   Please copy the credentials shown above');
+      }
       
       console.log('\n========================================');
       console.log('✅ Admin user created successfully!');
       console.log('========================================');
-      console.log('Username: admin');
+      console.log(`Email: ${adminEmail}`);
       console.log(`Password: ${generatedPassword}`);
       console.log('\n⚠️  IMPORTANT:');
       console.log('1. Save these credentials securely');
-      console.log('2. You will be required to change the password on first login');
-      console.log('3. Credentials are also saved in: ADMIN_CREDENTIALS.txt');
+      console.log('2. Please change the password after first login');
       console.log('========================================\n');
     }
     
     // Create default email templates if none exist
-    const templateExists = await db('email_templates').first();
+    const templateExists = await knex('email_templates').first();
     if (!templateExists) {
-      await db('email_templates').insert([
+      await knex('email_templates').insert([
         {
           template_key: 'gallery_created',
           subject: 'Your Photo Gallery is Ready!',
@@ -101,9 +117,9 @@ Generated on: ${new Date().toISOString()}
     }
 
     // Create default email config if none exists
-    const emailConfig = await db('email_configs').first();
+    const emailConfig = await knex('email_configs').first();
     if (!emailConfig) {
-      await db('email_configs').insert({
+      await knex('email_configs').insert({
         smtp_host: process.env.SMTP_HOST || 'mailhog',
         smtp_port: process.env.SMTP_PORT || 1025,
         smtp_secure: process.env.SMTP_SECURE === 'true',
@@ -116,11 +132,13 @@ Generated on: ${new Date().toISOString()}
     }
 
     console.log('Migrations completed successfully');
-    process.exit(0);
   } catch (error) {
-    console.error('Migration failed:', error);
-    process.exit(1);
+    console.error('Initial setup failed:', error);
+    throw error;
   }
-}
+};
 
-runMigrations();
+exports.down = async function(knex) {
+  // This migration cannot be rolled back as it creates the initial schema
+  console.log('Initial setup cannot be rolled back');
+};

backend/migrations/core/029_add_backup_service_tables.js

@@ -0,0 +1,220 @@
+const { db } = require('../../src/database/db');
+
+async function up() {
+  console.log('Adding backup service tables and settings...');
+  
+  // Create backup_runs table to track backup history
+  const hasBackupRunsTable = await db.schema.hasTable('backup_runs');
+  if (!hasBackupRunsTable) {
+    await db.schema.createTable('backup_runs', (table) => {
+      table.increments('id').primary();
+      table.datetime('started_at').notNullable();
+      table.datetime('completed_at');
+      table.string('status').defaultTo('running'); // running, completed, failed
+      table.string('backup_type'); // full, incremental
+      table.integer('files_backed_up').defaultTo(0);
+      table.bigInteger('total_size_bytes').defaultTo(0);
+      table.integer('duration_seconds');
+      table.text('error_message');
+      table.json('statistics'); // Detailed stats about the backup
+      table.json('file_checksums'); // Store checksums for change detection
+    });
+  }
+
+  // Create backup_file_states table to track individual file states
+  const hasBackupFileStatesTable = await db.schema.hasTable('backup_file_states');
+  if (!hasBackupFileStatesTable) {
+    await db.schema.createTable('backup_file_states', (table) => {
+      table.increments('id').primary();
+      table.string('file_path').notNullable();
+      table.string('checksum').notNullable();
+      table.bigInteger('size_bytes');
+      table.datetime('last_modified');
+      table.datetime('last_backed_up');
+      table.boolean('is_archived').defaultTo(false);
+      table.index(['file_path'], 'idx_backup_file_path');
+      table.index(['checksum'], 'idx_backup_checksum');
+    });
+  }
+
+  // Add backup-related settings to app_settings
+  const backupSettings = [
+    {
+      setting_key: 'backup_enabled',
+      setting_value: JSON.stringify(false),
+      setting_type: 'backup'
+    },
+    {
+      setting_key: 'backup_schedule',
+      setting_value: JSON.stringify('0 2 * * *'), // Default: 2 AM daily
+      setting_type: 'backup'
+    },
+    {
+      setting_key: 'backup_destination_type',
+      setting_value: JSON.stringify('local'), // local, rsync, s3
+      setting_type: 'backup'
+    },
+    {
+      setting_key: 'backup_destination_path',
+      setting_value: JSON.stringify('/backup/picpeak'),
+      setting_type: 'backup'
+    },
+    {
+      setting_key: 'backup_rsync_host',
+      setting_value: JSON.stringify(''),
+      setting_type: 'backup'
+    },
+    {
+      setting_key: 'backup_rsync_user',
+      setting_value: JSON.stringify(''),
+      setting_type: 'backup'
+    },
+    {
+      setting_key: 'backup_rsync_path',
+      setting_value: JSON.stringify(''),
+      setting_type: 'backup'
+    },
+    {
+      setting_key: 'backup_rsync_ssh_key',
+      setting_value: JSON.stringify(''),
+      setting_type: 'backup'
+    },
+    {
+      setting_key: 'backup_s3_endpoint',
+      setting_value: JSON.stringify(''),
+      setting_type: 'backup'
+    },
+    {
+      setting_key: 'backup_s3_bucket',
+      setting_value: JSON.stringify(''),
+      setting_type: 'backup'
+    },
+    {
+      setting_key: 'backup_s3_access_key',
+      setting_value: JSON.stringify(''),
+      setting_type: 'backup'
+    },
+    {
+      setting_key: 'backup_s3_secret_key',
+      setting_value: JSON.stringify(''),
+      setting_type: 'backup'
+    },
+    {
+      setting_key: 'backup_s3_region',
+      setting_value: JSON.stringify('us-east-1'),
+      setting_type: 'backup'
+    },
+    {
+      setting_key: 'backup_retention_days',
+      setting_value: JSON.stringify(30),
+      setting_type: 'backup'
+    },
+    {
+      setting_key: 'backup_include_archived',
+      setting_value: JSON.stringify(true),
+      setting_type: 'backup'
+    },
+    {
+      setting_key: 'backup_compression',
+      setting_value: JSON.stringify(true),
+      setting_type: 'backup'
+    },
+    {
+      setting_key: 'backup_email_on_failure',
+      setting_value: JSON.stringify(true),
+      setting_type: 'backup'
+    },
+    {
+      setting_key: 'backup_email_on_success',
+      setting_value: JSON.stringify(false),
+      setting_type: 'backup'
+    },
+    {
+      setting_key: 'backup_max_file_size_mb',
+      setting_value: JSON.stringify(5000), // Skip files larger than 5GB
+      setting_type: 'backup'
+    },
+    {
+      setting_key: 'backup_exclude_patterns',
+      setting_value: JSON.stringify(['*.tmp', '.DS_Store', 'Thumbs.db']),
+      setting_type: 'backup'
+    }
+  ];
+
+  // Insert backup settings if they don't exist
+  for (const setting of backupSettings) {
+    const exists = await db('app_settings')
+      .where('setting_key', setting.setting_key)
+      .first();
+    
+    if (!exists) {
+      await db('app_settings').insert(setting);
+    }
+  }
+
+  // Add backup-related email templates
+  const backupEmailTemplates = [
+    {
+      template_key: 'backup_failed',
+      subject: 'Backup Failed - Immediate Attention Required',
+      body_html: `<h2>Backup Failed</h2>
+<p>The scheduled backup has failed and requires immediate attention.</p>
+<p><strong>Error Details:</strong></p>
+<ul>
+  <li>Start Time: {{start_time}}</li>
+  <li>Backup Type: {{backup_type}}</li>
+  <li>Error: {{error_message}}</li>
+</ul>
+<p>Please check the system logs for more details and resolve the issue as soon as possible.</p>`,
+      body_text: 'Backup Failed\n\nThe scheduled backup has failed and requires immediate attention.\n\nStart Time: {{start_time}}\nBackup Type: {{backup_type}}\nError: {{error_message}}\n\nPlease check the system logs for more details.',
+      variables: JSON.stringify(['start_time', 'backup_type', 'error_message'])
+    },
+    {
+      template_key: 'backup_completed',
+      subject: 'Backup Completed Successfully',
+      body_html: `<h2>Backup Completed</h2>
+<p>The scheduled backup has been completed successfully.</p>
+<p><strong>Backup Summary:</strong></p>
+<ul>
+  <li>Start Time: {{start_time}}</li>
+  <li>Duration: {{duration}}</li>
+  <li>Files Backed Up: {{files_count}}</li>
+  <li>Total Size: {{total_size}}</li>
+  <li>Backup Type: {{backup_type}}</li>
+</ul>`,
+      body_text: 'Backup Completed\n\nThe scheduled backup has been completed successfully.\n\nStart Time: {{start_time}}\nDuration: {{duration}}\nFiles Backed Up: {{files_count}}\nTotal Size: {{total_size}}\nBackup Type: {{backup_type}}',
+      variables: JSON.stringify(['start_time', 'duration', 'files_count', 'total_size', 'backup_type'])
+    }
+  ];
+
+  // Insert backup email templates if they don't exist
+  for (const template of backupEmailTemplates) {
+    const exists = await db('email_templates')
+      .where('template_key', template.template_key)
+      .first();
+    
+    if (!exists) {
+      await db('email_templates').insert(template);
+    }
+  }
+
+  console.log('Backup service tables and settings added successfully');
+}
+
+async function down() {
+  // Remove backup tables
+  await db.schema.dropTableIfExists('backup_file_states');
+  await db.schema.dropTableIfExists('backup_runs');
+  
+  // Remove backup settings
+  await db('app_settings')
+    .where('setting_type', 'backup')
+    .delete();
+  
+  // Remove backup email templates
+  await db('email_templates')
+    .whereIn('template_key', ['backup_failed', 'backup_completed'])
+    .delete();
+}
+
+module.exports = { up, down };

backend/migrations/core/030_add_database_backup_tables.js

@@ -0,0 +1,159 @@
+const { db } = require('../../src/database/db');
+
+async function up() {
+  console.log('Adding database backup tables and settings...');
+  
+  // Create database_backup_runs table to track database backup history
+  const hasDatabaseBackupRunsTable = await db.schema.hasTable('database_backup_runs');
+  if (!hasDatabaseBackupRunsTable) {
+    await db.schema.createTable('database_backup_runs', (table) => {
+      table.increments('id').primary();
+      table.datetime('started_at').notNullable();
+      table.datetime('completed_at');
+      table.string('status').defaultTo('running'); // running, completed, failed
+      table.string('backup_type'); // sqlite, postgresql
+      table.string('destination_path');
+      table.string('file_path');
+      table.bigInteger('file_size_bytes').defaultTo(0);
+      table.bigInteger('original_size_bytes').defaultTo(0);
+      table.integer('duration_seconds');
+      table.string('checksum'); // SHA256 checksum of backup file
+      table.float('compression_ratio'); // Compression percentage
+      table.json('table_checksums'); // Individual table checksums
+      table.text('error_message');
+      table.json('statistics'); // Detailed stats about the backup
+      table.index(['started_at'], 'idx_db_backup_started');
+      table.index(['status'], 'idx_db_backup_status');
+    });
+  }
+
+  // Add database backup-related settings to app_settings
+  const databaseBackupSettings = [
+    {
+      setting_key: 'database_backup_enabled',
+      setting_value: JSON.stringify(false),
+      setting_type: 'database_backup'
+    },
+    {
+      setting_key: 'database_backup_schedule',
+      setting_value: JSON.stringify('0 3 * * *'), // Default: 3 AM daily
+      setting_type: 'database_backup'
+    },
+    {
+      setting_key: 'database_backup_destination_path',
+      setting_value: JSON.stringify('/backup/database'),
+      setting_type: 'database_backup'
+    },
+    {
+      setting_key: 'database_backup_compress',
+      setting_value: JSON.stringify(true),
+      setting_type: 'database_backup'
+    },
+    {
+      setting_key: 'database_backup_validate_integrity',
+      setting_value: JSON.stringify(true),
+      setting_type: 'database_backup'
+    },
+    {
+      setting_key: 'database_backup_include_checksums',
+      setting_value: JSON.stringify(true),
+      setting_type: 'database_backup'
+    },
+    {
+      setting_key: 'database_backup_retention_days',
+      setting_value: JSON.stringify(30),
+      setting_type: 'database_backup'
+    },
+    {
+      setting_key: 'database_backup_email_on_failure',
+      setting_value: JSON.stringify(true),
+      setting_type: 'database_backup'
+    },
+    {
+      setting_key: 'database_backup_email_on_success',
+      setting_value: JSON.stringify(false),
+      setting_type: 'database_backup'
+    },
+    {
+      setting_key: 'database_backup_max_retries',
+      setting_value: JSON.stringify(3),
+      setting_type: 'database_backup'
+    }
+  ];
+
+  // Insert database backup settings if they don't exist
+  for (const setting of databaseBackupSettings) {
+    const exists = await db('app_settings')
+      .where('setting_key', setting.setting_key)
+      .first();
+    
+    if (!exists) {
+      await db('app_settings').insert(setting);
+    }
+  }
+
+  // Add database backup-related email templates
+  const databaseBackupEmailTemplates = [
+    {
+      template_key: 'database_backup_failed',
+      subject: 'Database Backup Failed - Critical Alert',
+      body_html: `<h2>Database Backup Failed</h2>
+<p>The scheduled database backup has failed and requires immediate attention.</p>
+<p><strong>Error Details:</strong></p>
+<ul>
+  <li>Backup Type: {{backup_type}}</li>
+  <li>Timestamp: {{timestamp}}</li>
+  <li>Error: {{error_message}}</li>
+</ul>
+<p>This is a critical issue that could affect disaster recovery. Please investigate immediately.</p>`,
+      body_text: 'Database Backup Failed\n\nThe scheduled database backup has failed.\n\nBackup Type: {{backup_type}}\nTimestamp: {{timestamp}}\nError: {{error_message}}\n\nThis is critical - please investigate immediately.',
+      variables: JSON.stringify(['backup_type', 'timestamp', 'error_message'])
+    },
+    {
+      template_key: 'database_backup_completed',
+      subject: 'Database Backup Completed Successfully',
+      body_html: `<h2>Database Backup Completed</h2>
+<p>The scheduled database backup has been completed successfully.</p>
+<p><strong>Backup Summary:</strong></p>
+<ul>
+  <li>Backup Type: {{backup_type}}</li>
+  <li>Duration: {{duration}}</li>
+  <li>File Size: {{file_size}}</li>
+  <li>Compression Ratio: {{compression_ratio}}</li>
+  <li>File Path: {{file_path}}</li>
+</ul>`,
+      body_text: 'Database Backup Completed\n\nThe scheduled database backup has been completed successfully.\n\nBackup Type: {{backup_type}}\nDuration: {{duration}}\nFile Size: {{file_size}}\nCompression Ratio: {{compression_ratio}}\nFile Path: {{file_path}}',
+      variables: JSON.stringify(['backup_type', 'duration', 'file_size', 'compression_ratio', 'file_path'])
+    }
+  ];
+
+  // Insert database backup email templates if they don't exist
+  for (const template of databaseBackupEmailTemplates) {
+    const exists = await db('email_templates')
+      .where('template_key', template.template_key)
+      .first();
+    
+    if (!exists) {
+      await db('email_templates').insert(template);
+    }
+  }
+
+  console.log('Database backup tables and settings added successfully');
+}
+
+async function down() {
+  // Remove database backup tables
+  await db.schema.dropTableIfExists('database_backup_runs');
+  
+  // Remove database backup settings
+  await db('app_settings')
+    .where('setting_type', 'database_backup')
+    .delete();
+  
+  // Remove database backup email templates
+  await db('email_templates')
+    .whereIn('template_key', ['database_backup_failed', 'database_backup_completed'])
+    .delete();
+}
+
+module.exports = { up, down };

backend/migrations/core/031_add_backup_manifest_columns.js

@@ -0,0 +1,86 @@
+const { db } = require('../../src/database/db');
+const logger = require('../../src/utils/logger');
+
+async function up() {
+  console.log('Adding backup manifest columns...');
+  
+  // Add manifest columns to backup_runs table
+  const hasManifestPath = await db.schema.hasColumn('backup_runs', 'manifest_path');
+  if (!hasManifestPath) {
+    await db.schema.alterTable('backup_runs', (table) => {
+      table.string('manifest_path'); // Path to the manifest file
+      table.string('manifest_id'); // Unique manifest ID
+      table.string('manifest_format').defaultTo('json'); // json or yaml
+    });
+  }
+
+  // Add backup manifest-related settings to app_settings
+  const manifestSettings = [
+    {
+      setting_key: 'backup_manifest_enabled',
+      setting_value: JSON.stringify(true),
+      setting_type: 'backup'
+    },
+    {
+      setting_key: 'backup_manifest_format',
+      setting_value: JSON.stringify('json'), // json or yaml
+      setting_type: 'backup'
+    },
+    {
+      setting_key: 'backup_manifest_path',
+      setting_value: JSON.stringify('/backup/manifests'),
+      setting_type: 'backup'
+    },
+    {
+      setting_key: 'backup_manifest_validate',
+      setting_value: JSON.stringify(true),
+      setting_type: 'backup'
+    },
+    {
+      setting_key: 'backup_manifest_include_checksums',
+      setting_value: JSON.stringify(true),
+      setting_type: 'backup'
+    }
+  ];
+
+  // Insert manifest settings if they don't exist
+  for (const setting of manifestSettings) {
+    const exists = await db('app_settings')
+      .where('setting_key', setting.setting_key)
+      .first();
+    
+    if (!exists) {
+      await db('app_settings').insert(setting);
+    }
+  }
+
+  console.log('✓ Backup manifest columns and settings added');
+}
+
+async function down() {
+  // Remove manifest columns from backup_runs table
+  const hasManifestPath = await db.schema.hasColumn('backup_runs', 'manifest_path');
+  if (hasManifestPath) {
+    await db.schema.alterTable('backup_runs', (table) => {
+      table.dropColumn('manifest_path');
+      table.dropColumn('manifest_id');
+      table.dropColumn('manifest_format');
+    });
+  }
+
+  // Remove manifest settings
+  await db('app_settings')
+    .where('setting_type', 'backup')
+    .whereIn('setting_key', [
+      'backup_manifest_enabled',
+      'backup_manifest_format',
+      'backup_manifest_path',
+      'backup_manifest_validate',
+      'backup_manifest_include_checksums'
+    ])
+    .delete();
+
+  console.log('✓ Backup manifest columns and settings removed');
+}
+
+module.exports = { up, down };

backend/migrations/core/032_add_restore_runs_table.js

@@ -0,0 +1,234 @@
+// No helpers needed for this migration
+
+/**
+ * Add restore_runs table for tracking restore operations
+ */
+exports.up = async function(knex) {
+  // Create restore_runs table
+  const hasRestoreRunsTable = await knex.schema.hasTable('restore_runs');
+  if (!hasRestoreRunsTable) {
+    await knex.schema.createTable('restore_runs', table => {
+    table.increments('id').primary();
+    
+    // Timing
+    table.timestamp('started_at').notNullable().defaultTo(knex.fn.now());
+    table.timestamp('completed_at');
+    table.integer('duration_seconds');
+    
+    // Status and type
+    table.string('status', 50).notNullable().defaultTo('running');
+    table.string('restore_type', 50).notNullable(); // full, database, files, selective
+    
+    // Source information
+    table.string('source', 500).notNullable(); // Backup source path or S3 URL
+    table.string('manifest_path', 500); // Path to manifest file
+    
+    // Results
+    table.text('error_message');
+    table.text('statistics'); // JSON object with detailed statistics
+    table.text('restore_log'); // JSON array of log entries
+    
+    // Safety backup
+    table.string('pre_restore_backup_path', 500); // Path to pre-restore safety backup
+    
+    // Flags
+    table.boolean('is_dry_run').defaultTo(false);
+    table.boolean('was_rollback_attempted').defaultTo(false);
+    table.boolean('was_successful').defaultTo(false);
+    
+    // Operator information
+    table.string('operator_type', 50).defaultTo('manual'); // manual, scheduled, api
+    table.integer('operator_user_id').references('id').inTable('admin_users').onDelete('SET NULL');
+    table.string('operator_ip', 50);
+    
+    // Metadata
+    table.text('metadata'); // JSON object for additional data
+    
+    table.index(['status', 'started_at']);
+    table.index(['restore_type', 'started_at']);
+    });
+  }
+  
+  // Create restore_file_operations table for tracking individual file operations
+  const hasRestoreFileOperationsTable = await knex.schema.hasTable('restore_file_operations');
+  if (!hasRestoreFileOperationsTable) {
+    await knex.schema.createTable('restore_file_operations', table => {
+    table.increments('id').primary();
+    
+    table.integer('restore_run_id').notNullable()
+      .references('id').inTable('restore_runs').onDelete('CASCADE');
+    
+    table.string('file_path', 500).notNullable();
+    table.string('operation', 50).notNullable(); // restore, skip, error
+    table.string('status', 50).notNullable(); // pending, in_progress, completed, failed
+    
+    table.bigInteger('file_size');
+    table.string('checksum', 64);
+    table.boolean('checksum_verified').defaultTo(false);
+    
+    table.text('error_message');
+    table.timestamp('started_at');
+    table.timestamp('completed_at');
+    
+    table.index(['restore_run_id', 'status']);
+    table.index(['file_path']);
+    });
+  }
+  
+  // Create restore_validation_results table
+  const hasRestoreValidationResultsTable = await knex.schema.hasTable('restore_validation_results');
+  if (!hasRestoreValidationResultsTable) {
+    await knex.schema.createTable('restore_validation_results', table => {
+    table.increments('id').primary();
+    
+    table.integer('restore_run_id').notNullable()
+      .references('id').inTable('restore_runs').onDelete('CASCADE');
+    
+    table.string('validation_type', 50).notNullable(); // pre-restore, post-restore
+    table.boolean('is_valid').notNullable();
+    
+    table.text('errors'); // JSON array of errors
+    table.text('warnings'); // JSON array of warnings
+    table.text('checksums'); // JSON object with checksum comparisons
+    
+    table.timestamp('validated_at').notNullable().defaultTo(knex.fn.now());
+    
+    table.index(['restore_run_id', 'validation_type']);
+    });
+  }
+  
+  // Add restore-related settings to app_settings
+  const restoreSettings = [
+    {
+      setting_key: 'restore_allow_force',
+      setting_value: JSON.stringify(false),
+      setting_type: 'restore'
+    },
+    {
+      setting_key: 'restore_require_pre_backup',
+      setting_value: JSON.stringify(true),
+      setting_type: 'restore'
+    },
+    {
+      setting_key: 'restore_max_file_size_mb',
+      setting_value: '5000',
+      setting_type: 'restore'
+    },
+    {
+      setting_key: 'restore_verify_checksums',
+      setting_value: JSON.stringify(true),
+      setting_type: 'restore'
+    },
+    {
+      setting_key: 'restore_email_on_completion',
+      setting_value: JSON.stringify(true),
+      setting_type: 'restore'
+    },
+    {
+      setting_key: 'restore_retention_days',
+      setting_value: '30',
+      setting_type: 'restore'
+    }
+  ];
+
+  for (const setting of restoreSettings) {
+    const exists = await knex('app_settings')
+      .where('setting_key', setting.setting_key)
+      .first();
+    
+    if (!exists) {
+      await knex('app_settings').insert(setting);
+    }
+  }
+  
+  // Add new email templates for restore notifications
+  const emailTemplates = [
+    {
+      template_key: 'restore_completed',
+      subject: '✅ Restore Completed Successfully',
+      body_html: `<h2>Restore Operation Completed</h2>
+<p>A restore operation has completed successfully.</p>
+
+<h3>Details:</h3>
+<ul>
+  <li><strong>Restore Type:</strong> {{restore_type}}</li>
+  <li><strong>Duration:</strong> {{duration}}</li>
+  <li><strong>Files Restored:</strong> {{files_restored}}</li>
+  <li><strong>Backup ID:</strong> {{backup_id}}</li>
+  <li><strong>Timestamp:</strong> {{timestamp}}</li>
+</ul>
+
+<p>Please verify that all systems are functioning correctly after the restore.</p>`,
+      body_text: `Restore Operation Completed
+
+A restore operation has completed successfully.
+
+Details:
+- Restore Type: {{restore_type}}
+- Duration: {{duration}}
+- Files Restored: {{files_restored}}
+- Backup ID: {{backup_id}}
+- Timestamp: {{timestamp}}
+
+Please verify that all systems are functioning correctly after the restore.`,
+      variables: JSON.stringify(['restore_type', 'duration', 'files_restored', 'backup_id', 'timestamp'])
+    },
+    {
+      template_key: 'restore_failed',
+      subject: '❌ Restore Operation Failed',
+      body_html: `<h2>Restore Operation Failed</h2>
+<p>A restore operation has failed and requires attention.</p>
+
+<h3>Details:</h3>
+<ul>
+  <li><strong>Restore Type:</strong> {{restore_type}}</li>
+  <li><strong>Error:</strong> {{error_message}}</li>
+  <li><strong>Timestamp:</strong> {{timestamp}}</li>
+</ul>
+
+<p>Please check the system logs for more details and take appropriate action.</p>
+
+<p><strong>Important:</strong> If a pre-restore backup was created, it may be used for recovery.</p>`,
+      body_text: `Restore Operation Failed
+
+A restore operation has failed and requires attention.
+
+Details:
+- Restore Type: {{restore_type}}
+- Error: {{error_message}}
+- Timestamp: {{timestamp}}
+
+Please check the system logs for more details and take appropriate action.
+
+Important: If a pre-restore backup was created, it may be used for recovery.`,
+      variables: JSON.stringify(['restore_type', 'error_message', 'timestamp'])
+    }
+  ];
+  
+  for (const template of emailTemplates) {
+    const exists = await knex('email_templates')
+      .where('template_key', template.template_key)
+      .first();
+    
+    if (!exists) {
+      await knex('email_templates').insert(template);
+    }
+  }
+};
+
+exports.down = async function(knex) {
+  // Remove email templates
+  await knex('email_templates')
+    .whereIn('template_key', ['restore_completed', 'restore_failed'])
+    .delete();
+  
+  // Remove settings
+  await knex('app_settings')
+    .where('setting_type', 'restore')
+    .delete();
+  
+  // Drop tables
+  await knex.schema.dropTableIfExists('restore_validation_results');
+  await knex.schema.dropTableIfExists('restore_file_operations');
+  await knex.schema.dropTableIfExists('restore_runs');
+};

backend/migrations/core/033_add_gallery_feedback.js

@@ -0,0 +1,152 @@
+// No helpers needed for boolean values
+
+exports.up = async function(knex) {
+  console.log('Adding gallery feedback tables...');
+  
+  // Check if tables and columns already exist
+  const hasEventFeedbackSettingsTable = await knex.schema.hasTable('event_feedback_settings');
+  const hasPhotoFeedbackTable = await knex.schema.hasTable('photo_feedback');
+  const hasFeedbackRateLimitsTable = await knex.schema.hasTable('feedback_rate_limits');
+  const hasFeedbackWordFiltersTable = await knex.schema.hasTable('feedback_word_filters');
+  const hasFeedbackCountColumn = await knex.schema.hasColumn('photos', 'feedback_count');
+  
+  // Create event_feedback_settings table
+  if (!hasEventFeedbackSettingsTable) {
+    await knex.schema.createTable('event_feedback_settings', (table) => {
+      table.increments('id').primary();
+      table.integer('event_id').references('id').inTable('events').onDelete('CASCADE');
+      table.boolean('feedback_enabled').defaultTo(false);
+      table.boolean('allow_ratings').defaultTo(true);
+      table.boolean('allow_likes').defaultTo(true);
+      table.boolean('allow_comments').defaultTo(false);
+      table.boolean('allow_favorites').defaultTo(true);
+      table.boolean('require_name_email').defaultTo(false);
+      table.boolean('moderate_comments').defaultTo(true);
+      table.boolean('show_feedback_to_guests').defaultTo(true);
+      table.timestamp('created_at').defaultTo(knex.fn.now());
+      table.timestamp('updated_at').defaultTo(knex.fn.now());
+      table.unique(['event_id']);
+    });
+  }
+
+  // Create photo_feedback table
+  if (!hasPhotoFeedbackTable) {
+    await knex.schema.createTable('photo_feedback', (table) => {
+      table.increments('id').primary();
+      table.integer('photo_id').references('id').inTable('photos').onDelete('CASCADE');
+      table.integer('event_id').references('id').inTable('events').onDelete('CASCADE');
+      table.string('feedback_type', 20).notNullable();
+      table.integer('rating');
+      table.text('comment_text');
+      table.string('guest_name', 100);
+      table.string('guest_email', 255);
+      table.string('guest_identifier', 64);
+      table.string('ip_address', 45);
+      table.text('user_agent');
+      table.boolean('is_approved').defaultTo(true);
+      table.boolean('is_hidden').defaultTo(false);
+      table.timestamp('created_at').defaultTo(knex.fn.now());
+      table.timestamp('updated_at').defaultTo(knex.fn.now());
+      
+      // Add indexes
+      table.index(['photo_id']);
+      table.index(['event_id']);
+      table.index(['feedback_type']);
+      table.index(['guest_identifier']);
+      
+      // Add check constraint for rating (PostgreSQL)
+      if (knex.client.config.client === 'pg') {
+        table.check('?? >= 1 AND ?? <= 5', ['rating', 'rating']);
+      }
+    });
+  }
+
+  // Create feedback_rate_limits table
+  if (!hasFeedbackRateLimitsTable) {
+    await knex.schema.createTable('feedback_rate_limits', (table) => {
+      table.increments('id').primary();
+      table.string('identifier', 64).notNullable();
+      table.integer('event_id').references('id').inTable('events').onDelete('CASCADE');
+      table.string('action_type', 20).notNullable();
+      table.integer('action_count').defaultTo(1);
+      table.timestamp('window_start').defaultTo(knex.fn.now());
+      
+      // Add indexes
+      table.index(['identifier', 'event_id', 'action_type']);
+      table.index(['window_start']);
+    });
+  }
+
+  // Create feedback_word_filters table
+  if (!hasFeedbackWordFiltersTable) {
+    await knex.schema.createTable('feedback_word_filters', (table) => {
+      table.increments('id').primary();
+      table.string('word', 100).notNullable();
+      table.string('severity', 20).defaultTo('moderate');
+      table.boolean('is_active').defaultTo(true);
+      table.timestamp('created_at').defaultTo(knex.fn.now());
+      table.unique(['word']);
+    });
+  }
+
+  // Add feedback summary columns to photos table
+  if (!hasFeedbackCountColumn) {
+    await knex.schema.alterTable('photos', (table) => {
+      table.integer('feedback_count').defaultTo(0);
+      table.integer('like_count').defaultTo(0);
+      table.decimal('average_rating', 3, 2).defaultTo(0);
+      table.integer('favorite_count').defaultTo(0);
+    });
+  }
+
+  // Add feedback notification settings to app_settings
+  const hasFeedbackNotificationEmail = await knex('app_settings')
+    .where('setting_key', 'feedback_notification_email')
+    .first();
+    
+  if (!hasFeedbackNotificationEmail) {
+    await knex('app_settings').insert([
+      {
+        setting_key: 'feedback_notification_email',
+        setting_value: JSON.stringify(''),
+        setting_type: 'feedback'
+      },
+      {
+        setting_key: 'feedback_rate_limits',
+        setting_value: JSON.stringify({
+          rating: { max: 100, window: 3600 }, // 100 ratings per hour
+          comment: { max: 20, window: 3600 }, // 20 comments per hour
+          like: { max: 200, window: 3600 } // 200 likes per hour
+        }),
+        setting_type: 'feedback'
+      }
+    ]);
+  }
+  
+  console.log('Gallery feedback tables created successfully');
+};
+
+exports.down = async function(knex) {
+  console.log('Removing gallery feedback tables...');
+  
+  // Remove feedback settings from app_settings
+  await knex('app_settings')
+    .whereIn('setting_key', ['feedback_notification_email', 'feedback_rate_limits'])
+    .delete();
+
+  // Remove feedback columns from photos table
+  await knex.schema.alterTable('photos', (table) => {
+    table.dropColumn('feedback_count');
+    table.dropColumn('like_count');
+    table.dropColumn('average_rating');
+    table.dropColumn('favorite_count');
+  });
+
+  // Drop tables in reverse order
+  await knex.schema.dropTableIfExists('feedback_word_filters');
+  await knex.schema.dropTableIfExists('feedback_rate_limits');
+  await knex.schema.dropTableIfExists('photo_feedback');
+  await knex.schema.dropTableIfExists('event_feedback_settings');
+  
+  console.log('Gallery feedback tables removed');
+};

backend/migrations/core/034_add_version_to_backups.js

@@ -0,0 +1,139 @@
+const { db } = require('../../src/database/db');
+
+async function up() {
+  console.log('Adding version tracking to backup tables...');
+  
+  // Add version columns to database_backup_runs table
+  const hasDatabaseBackupRunsTable = await db.schema.hasTable('database_backup_runs');
+  if (hasDatabaseBackupRunsTable) {
+    const hasAppVersion = await db.schema.hasColumn('database_backup_runs', 'app_version');
+    if (!hasAppVersion) {
+      await db.schema.alterTable('database_backup_runs', (table) => {
+        table.string('app_version'); // Application version
+        table.string('node_version'); // Node.js version
+        table.string('db_schema_version'); // Database schema version (migration name)
+        table.json('environment_info'); // Additional environment information
+      });
+      console.log('Added version columns to database_backup_runs table');
+    }
+  }
+
+  // Add version columns to backup_runs table (file backups)
+  const hasBackupRunsTable = await db.schema.hasTable('backup_runs');
+  if (hasBackupRunsTable) {
+    const hasAppVersion = await db.schema.hasColumn('backup_runs', 'app_version');
+    if (!hasAppVersion) {
+      await db.schema.alterTable('backup_runs', (table) => {
+        table.string('app_version'); // Application version
+        table.string('node_version'); // Node.js version
+        table.string('db_schema_version'); // Database schema version
+        table.json('manifest_info'); // Manifest summary information
+      });
+      console.log('Added version columns to backup_runs table');
+    }
+  }
+
+  // Add restore tracking table
+  const hasRestoreHistoryTable = await db.schema.hasTable('restore_history');
+  if (!hasRestoreHistoryTable) {
+    await db.schema.createTable('restore_history', (table) => {
+      table.increments('id').primary();
+      table.datetime('started_at').notNullable();
+      table.datetime('completed_at');
+      table.string('status').defaultTo('running'); // running, completed, failed, partial
+      table.string('restore_type'); // database, files, full
+      table.string('backup_id'); // Reference to the backup that was restored
+      table.string('backup_app_version'); // Version of app that created the backup
+      table.string('restore_app_version'); // Version of app performing the restore
+      table.string('backup_node_version'); // Node version that created the backup
+      table.string('restore_node_version'); // Node version performing the restore
+      table.string('backup_schema_version'); // Schema version in the backup
+      table.string('restore_schema_version'); // Current schema version
+      table.json('version_compatibility'); // Compatibility check results
+      table.json('restore_options'); // Options used during restore
+      table.json('statistics'); // Restore statistics
+      table.text('warnings'); // Any warnings during restore
+      table.text('error_message'); // Error details if failed
+      table.string('restored_by'); // User who initiated the restore
+      table.index(['started_at'], 'idx_restore_started');
+      table.index(['backup_id'], 'idx_restore_backup_id');
+    });
+    console.log('Created restore_history table');
+  }
+
+  // Add version compatibility settings
+  const versionSettings = [
+    {
+      setting_key: 'backup_require_version_match',
+      setting_value: JSON.stringify(false), // If true, exact version match required for restore
+      setting_type: 'backup'
+    },
+    {
+      setting_key: 'backup_allow_minor_version_mismatch',
+      setting_value: JSON.stringify(true), // Allow restoring from same major version
+      setting_type: 'backup'
+    },
+    {
+      setting_key: 'backup_warn_on_version_mismatch',
+      setting_value: JSON.stringify(true), // Show warning when versions don't match
+      setting_type: 'backup'
+    },
+    {
+      setting_key: 'backup_check_schema_compatibility',
+      setting_value: JSON.stringify(true), // Check if migrations are compatible
+      setting_type: 'backup'
+    }
+  ];
+
+  // Insert version settings if they don't exist
+  for (const setting of versionSettings) {
+    const exists = await db('app_settings')
+      .where('setting_key', setting.setting_key)
+      .first();
+    
+    if (!exists) {
+      await db('app_settings').insert(setting);
+    }
+  }
+
+  console.log('Version tracking for backups added successfully');
+}
+
+async function down() {
+  // Remove version columns from database_backup_runs
+  const hasDatabaseBackupRunsTable = await db.schema.hasTable('database_backup_runs');
+  if (hasDatabaseBackupRunsTable) {
+    await db.schema.alterTable('database_backup_runs', (table) => {
+      table.dropColumn('app_version');
+      table.dropColumn('node_version');
+      table.dropColumn('db_schema_version');
+      table.dropColumn('environment_info');
+    });
+  }
+
+  // Remove version columns from backup_runs
+  const hasBackupRunsTable = await db.schema.hasTable('backup_runs');
+  if (hasBackupRunsTable) {
+    await db.schema.alterTable('backup_runs', (table) => {
+      table.dropColumn('app_version');
+      table.dropColumn('node_version');
+      table.dropColumn('db_schema_version');
+      table.dropColumn('manifest_info');
+    });
+  }
+
+  // Drop restore_history table
+  await db.schema.dropTableIfExists('restore_history');
+
+  // Remove version settings
+  await db('app_settings')
+    .whereIn('setting_key', [
+      'backup_require_version_match',
+      'backup_allow_minor_version_mismatch',
+      'backup_warn_on_version_mismatch',
+      'backup_check_schema_compatibility'
+    ])
+    .delete();
+}
+
+module.exports = { up, down };

backend/migrations/core/035_enhance_backup_system.js

@@ -0,0 +1,221 @@
+const { db } = require('../../src/database/db');
+
+async function up() {
+  console.log('Enhancing backup system...');
+  
+  // Add new settings to app_settings table if they don't exist
+  const backupSettings = [
+    {
+      setting_key: 'backup_s3_force_path_style',
+      setting_value: JSON.stringify(false),
+      setting_type: 'backup'
+    },
+    {
+      setting_key: 'backup_s3_ssl_enabled',
+      setting_value: JSON.stringify(true),
+      setting_type: 'backup'
+    },
+    {
+      setting_key: 'backup_s3_prefix',
+      setting_value: JSON.stringify(''),
+      setting_type: 'backup'
+    },
+    {
+      setting_key: 'backup_incremental',
+      setting_value: JSON.stringify(false),
+      setting_type: 'backup'
+    },
+    {
+      setting_key: 'backup_include_database',
+      setting_value: JSON.stringify(true),
+      setting_type: 'backup'
+    },
+    {
+      setting_key: 'backup_encryption_enabled',
+      setting_value: JSON.stringify(false),
+      setting_type: 'backup'
+    },
+    {
+      setting_key: 'backup_database_schedule',
+      setting_value: JSON.stringify(''),
+      setting_type: 'backup'
+    }
+  ];
+
+  // Insert settings if they don't exist
+  for (const setting of backupSettings) {
+    const exists = await db('app_settings')
+      .where('setting_key', setting.setting_key)
+      .first();
+    
+    if (!exists) {
+      await db('app_settings').insert(setting);
+    }
+  }
+
+  // Check and add columns to backup_runs table
+  const hasBackupRunsTable = await db.schema.hasTable('backup_runs');
+  if (hasBackupRunsTable) {
+    // Check for existing columns before adding
+    const hasManifestPath = await db.schema.hasColumn('backup_runs', 'manifest_path');
+    const hasManifestId = await db.schema.hasColumn('backup_runs', 'manifest_id');
+    const hasManifestFormat = await db.schema.hasColumn('backup_runs', 'manifest_format');
+    const hasParentBackupId = await db.schema.hasColumn('backup_runs', 'parent_backup_id');
+    const hasBackupMode = await db.schema.hasColumn('backup_runs', 'backup_mode');
+    
+    if (!hasManifestPath || !hasManifestId || !hasManifestFormat || !hasParentBackupId || !hasBackupMode) {
+      await db.schema.alterTable('backup_runs', (table) => {
+        if (!hasManifestPath) {
+          table.string('manifest_path', 500).comment('Path to backup manifest file');
+        }
+        if (!hasManifestId) {
+          table.uuid('manifest_id').comment('Unique identifier for the manifest');
+        }
+        if (!hasManifestFormat) {
+          table.enum('manifest_format', ['json', 'yaml']).comment('Format of the manifest file');
+        }
+        if (!hasParentBackupId) {
+          table.integer('parent_backup_id').unsigned().references('id').inTable('backup_runs').onDelete('SET NULL').comment('Parent backup for incremental backups');
+        }
+        if (!hasBackupMode) {
+          table.enum('backup_mode', ['full', 'incremental', 'database']).defaultTo('full').comment('Type of backup performed');
+        }
+      });
+    }
+    
+    // Add indexes if they don't exist
+    try {
+      await db.raw('CREATE INDEX IF NOT EXISTS idx_backup_runs_mode_status ON backup_runs(backup_mode, status)');
+      await db.raw('CREATE INDEX IF NOT EXISTS idx_backup_runs_parent ON backup_runs(parent_backup_id)');
+      await db.raw('CREATE INDEX IF NOT EXISTS idx_backup_runs_created_mode ON backup_runs(created_at, backup_mode)');
+    } catch (error) {
+      console.log('Note: Some indexes may already exist, continuing...');
+    }
+  }
+
+  // Create backup_manifest table if it doesn't exist
+  const hasManifestTable = await db.schema.hasTable('backup_manifest');
+  if (!hasManifestTable) {
+    await db.schema.createTable('backup_manifest', (table) => {
+      table.increments('id').primary();
+      table.integer('backup_run_id').unsigned().notNullable().references('id').inTable('backup_runs').onDelete('CASCADE');
+      table.uuid('manifest_id').notNullable().unique().comment('Unique identifier matching backup_runs.manifest_id');
+      table.string('version', 20).notNullable().defaultTo('1.0.0').comment('Manifest schema version');
+      table.enum('format', ['json', 'yaml']).notNullable().defaultTo('json');
+      
+      // Backup metadata
+      table.timestamp('backup_start').notNullable();
+      table.timestamp('backup_end').notNullable();
+      table.bigInteger('total_size').unsigned().comment('Total size of backup in bytes');
+      table.integer('file_count').unsigned().comment('Number of files in backup');
+      table.integer('photo_count').unsigned().comment('Number of photos backed up');
+      table.integer('event_count').unsigned().comment('Number of events backed up');
+      
+      // Incremental backup metadata
+      table.boolean('is_incremental').defaultTo(false);
+      table.uuid('parent_manifest_id').comment('Parent manifest ID for incremental backups');
+      table.timestamp('incremental_since').comment('Timestamp for incremental backup baseline');
+      
+      // Content checksums
+      table.string('checksum_algorithm', 50).defaultTo('sha256').comment('Algorithm used for checksums');
+      table.text('manifest_checksum').comment('Checksum of the manifest file itself');
+      
+      // Storage information
+      table.string('storage_location', 500).comment('Primary storage location (local path or S3 URI)');
+      table.string('storage_provider', 50).comment('Storage provider (local, s3, etc.)');
+      
+      // Encryption metadata
+      table.boolean('is_encrypted').defaultTo(false);
+      table.string('encryption_algorithm', 100).comment('Encryption algorithm used');
+      table.string('encryption_key_id', 255).comment('ID of encryption key used');
+      
+      // Additional metadata as JSON
+      table.json('metadata').comment('Additional metadata as JSON');
+      
+      // Timestamps
+      table.timestamps(true, true);
+      
+      // Indexes
+      table.index(['backup_run_id'], 'idx_manifest_backup_run');
+      table.index(['manifest_id'], 'idx_manifest_uuid');
+      table.index(['parent_manifest_id'], 'idx_manifest_parent');
+      table.index(['backup_start', 'backup_end'], 'idx_manifest_time_range');
+      table.index(['is_incremental', 'created_at'], 'idx_manifest_incremental_created');
+    });
+  }
+
+  // Add composite indexes for common query patterns
+  try {
+    await db.raw(`
+      CREATE INDEX IF NOT EXISTS idx_backup_runs_recent_successful 
+      ON backup_runs(created_at DESC) 
+      WHERE status = 'completed' AND backup_mode = 'full';
+    `);
+    await db.raw(`
+      CREATE INDEX IF NOT EXISTS idx_backup_runs_incremental_chain 
+      ON backup_runs(parent_backup_id, created_at) 
+      WHERE backup_mode = 'incremental';
+    `);
+  } catch (error) {
+    console.log('Note: Some composite indexes may already exist, continuing...');
+  }
+
+  console.log('Backup system enhancements completed');
+}
+
+async function down() {
+  // Drop indexes first
+  try {
+    await db.raw('DROP INDEX IF EXISTS idx_backup_runs_incremental_chain;');
+    await db.raw('DROP INDEX IF EXISTS idx_backup_runs_recent_successful;');
+  } catch (error) {
+    // Ignore errors if indexes don't exist
+  }
+
+  // Drop backup_manifest table
+  await db.schema.dropTableIfExists('backup_manifest');
+
+  // Remove columns from backup_runs if they exist
+  const hasBackupRunsTable = await db.schema.hasTable('backup_runs');
+  if (hasBackupRunsTable) {
+    const hasBackupMode = await db.schema.hasColumn('backup_runs', 'backup_mode');
+    const hasParentBackupId = await db.schema.hasColumn('backup_runs', 'parent_backup_id');
+    const hasManifestFormat = await db.schema.hasColumn('backup_runs', 'manifest_format');
+    const hasManifestId = await db.schema.hasColumn('backup_runs', 'manifest_id');
+    const hasManifestPath = await db.schema.hasColumn('backup_runs', 'manifest_path');
+    
+    if (hasBackupMode || hasParentBackupId || hasManifestFormat || hasManifestId || hasManifestPath) {
+      await db.schema.alterTable('backup_runs', (table) => {
+        if (hasBackupMode) table.dropColumn('backup_mode');
+        if (hasParentBackupId) table.dropColumn('parent_backup_id');
+        if (hasManifestFormat) table.dropColumn('manifest_format');
+        if (hasManifestId) table.dropColumn('manifest_id');
+        if (hasManifestPath) table.dropColumn('manifest_path');
+      });
+    }
+    
+    // Drop indexes
+    try {
+      await db.raw('DROP INDEX IF EXISTS idx_backup_runs_mode_status');
+      await db.raw('DROP INDEX IF EXISTS idx_backup_runs_parent');
+      await db.raw('DROP INDEX IF EXISTS idx_backup_runs_created_mode');
+    } catch (error) {
+      // Ignore errors if indexes don't exist
+    }
+  }
+
+  // Remove settings
+  await db('app_settings')
+    .whereIn('setting_key', [
+      'backup_s3_force_path_style',
+      'backup_s3_ssl_enabled',
+      'backup_s3_prefix',
+      'backup_incremental',
+      'backup_include_database',
+      'backup_encryption_enabled',
+      'backup_database_schedule'
+    ])
+    .delete();
+}
+
+module.exports = { up, down };

backend/migrations/core/036_fix_missing_columns.js

@@ -0,0 +1,87 @@
+// Fix missing columns identified in GitHub issues
+
+exports.up = async function(knex) {
+  console.log('Adding missing columns to database tables...');
+  
+  // Add must_change_password column to admin_users table
+  const hasMustChangePassword = await knex.schema.hasColumn('admin_users', 'must_change_password');
+  if (!hasMustChangePassword) {
+    console.log('Adding must_change_password column to admin_users table...');
+    await knex.schema.table('admin_users', (table) => {
+      table.boolean('must_change_password').defaultTo(false);
+    });
+  }
+  
+  // Add password_changed_at column to admin_users table
+  const hasPasswordChangedAt = await knex.schema.hasColumn('admin_users', 'password_changed_at');
+  if (!hasPasswordChangedAt) {
+    console.log('Adding password_changed_at column to admin_users table...');
+    await knex.schema.table('admin_users', (table) => {
+      table.datetime('password_changed_at');
+    });
+  }
+  
+  // Add require_moderation column to event_feedback_settings table
+  const hasEventFeedbackSettings = await knex.schema.hasTable('event_feedback_settings');
+  if (hasEventFeedbackSettings) {
+    const hasRequireModeration = await knex.schema.hasColumn('event_feedback_settings', 'require_moderation');
+    if (!hasRequireModeration) {
+      console.log('Adding require_moderation column to event_feedback_settings table...');
+      await knex.schema.table('event_feedback_settings', (table) => {
+        table.boolean('require_moderation').defaultTo(true);
+      });
+    }
+  }
+  
+  // Add host_name column to events table if missing
+  const hasHostName = await knex.schema.hasColumn('events', 'host_name');
+  if (!hasHostName) {
+    console.log('Adding host_name column to events table...');
+    await knex.schema.table('events', (table) => {
+      table.string('host_name');
+    });
+  }
+  
+  console.log('Missing columns have been added successfully');
+};
+
+exports.down = async function(knex) {
+  console.log('Removing added columns...');
+  
+  // Remove must_change_password column from admin_users table
+  const hasMustChangePassword = await knex.schema.hasColumn('admin_users', 'must_change_password');
+  if (hasMustChangePassword) {
+    await knex.schema.table('admin_users', (table) => {
+      table.dropColumn('must_change_password');
+    });
+  }
+  
+  // Remove password_changed_at column from admin_users table
+  const hasPasswordChangedAt = await knex.schema.hasColumn('admin_users', 'password_changed_at');
+  if (hasPasswordChangedAt) {
+    await knex.schema.table('admin_users', (table) => {
+      table.dropColumn('password_changed_at');
+    });
+  }
+  
+  // Remove require_moderation column from event_feedback_settings table
+  const hasEventFeedbackSettings = await knex.schema.hasTable('event_feedback_settings');
+  if (hasEventFeedbackSettings) {
+    const hasRequireModeration = await knex.schema.hasColumn('event_feedback_settings', 'require_moderation');
+    if (hasRequireModeration) {
+      await knex.schema.table('event_feedback_settings', (table) => {
+        table.dropColumn('require_moderation');
+      });
+    }
+  }
+  
+  // Remove host_name column from events table
+  const hasHostName = await knex.schema.hasColumn('events', 'host_name');
+  if (hasHostName) {
+    await knex.schema.table('events', (table) => {
+      table.dropColumn('host_name');
+    });
+  }
+  
+  console.log('Columns removed');
+};

backend/migrations/core/037_add_download_controls.js

@@ -0,0 +1,69 @@
+// Add download control features to events table
+
+exports.up = async function(knex) {
+  console.log('Adding download control columns to events table...');
+  
+  // Add download control columns to events table
+  const hasAllowDownloads = await knex.schema.hasColumn('events', 'allow_downloads');
+  if (!hasAllowDownloads) {
+    await knex.schema.table('events', (table) => {
+      table.boolean('allow_downloads').defaultTo(true);
+      table.boolean('disable_right_click').defaultTo(false);
+      table.boolean('watermark_downloads').defaultTo(false);
+      table.text('watermark_text');
+    });
+  }
+  
+  // Add download control settings to app_settings
+  const downloadSettingExists = await knex('app_settings')
+    .where('setting_key', 'default_allow_downloads')
+    .first();
+    
+  if (!downloadSettingExists) {
+    await knex('app_settings').insert([
+      {
+        setting_key: 'default_allow_downloads',
+        setting_value: JSON.stringify(true),
+        setting_type: 'gallery'
+      },
+      {
+        setting_key: 'default_disable_right_click',
+        setting_value: JSON.stringify(false),
+        setting_type: 'gallery'
+      },
+      {
+        setting_key: 'default_watermark_downloads',
+        setting_value: JSON.stringify(false),
+        setting_type: 'gallery'
+      }
+    ]);
+  }
+  
+  console.log('Download control features added successfully');
+};
+
+exports.down = async function(knex) {
+  console.log('Removing download control columns...');
+  
+  // Remove app settings
+  await knex('app_settings')
+    .whereIn('setting_key', [
+      'default_allow_downloads',
+      'default_disable_right_click', 
+      'default_watermark_downloads'
+    ])
+    .delete();
+  
+  // Remove columns from events table
+  const hasAllowDownloads = await knex.schema.hasColumn('events', 'allow_downloads');
+  if (hasAllowDownloads) {
+    await knex.schema.table('events', (table) => {
+      table.dropColumn('allow_downloads');
+      table.dropColumn('disable_right_click');
+      table.dropColumn('watermark_downloads');
+      table.dropColumn('watermark_text');
+    });
+  }
+  
+  console.log('Download control columns removed');
+};

backend/migrations/core/038_add_enhanced_image_protection.js

@@ -0,0 +1,128 @@
+// Add enhanced image protection features
+
+exports.up = async function(knex) {
+  console.log('Adding enhanced image protection features...');
+  
+  // Add protection columns to events table
+  const hasProtectionLevel = await knex.schema.hasColumn('events', 'protection_level');
+  if (!hasProtectionLevel) {
+    await knex.schema.table('events', (table) => {
+      table.enum('protection_level', ['basic', 'standard', 'enhanced', 'maximum']).defaultTo('standard');
+      table.integer('image_quality').defaultTo(85);
+      table.boolean('add_fingerprint').defaultTo(true);
+      table.boolean('enable_devtools_protection').defaultTo(true);
+      table.boolean('use_canvas_rendering').defaultTo(false);
+      table.integer('fragmentation_level').defaultTo(3);
+      table.boolean('overlay_protection').defaultTo(true);
+    });
+  }
+  
+  // Create image access logs table
+  const hasImageAccessLogs = await knex.schema.hasTable('image_access_logs');
+  if (!hasImageAccessLogs) {
+    await knex.schema.createTable('image_access_logs', (table) => {
+      table.increments('id').primary();
+      table.integer('photo_id').unsigned().notNullable();
+      table.integer('event_id').unsigned().notNullable();
+      table.string('client_ip', 45).notNullable();
+      table.text('user_agent');
+      table.string('access_type', 20).defaultTo('view'); // view, download, suspicious
+      table.string('client_fingerprint', 32).notNullable();
+      table.timestamp('accessed_at').defaultTo(knex.fn.now());
+      table.json('metadata'); // Additional security metadata
+      
+      table.foreign('photo_id').references('id').inTable('photos').onDelete('CASCADE');
+      table.foreign('event_id').references('id').inTable('events').onDelete('CASCADE');
+      
+      table.index(['photo_id', 'accessed_at']);
+      table.index(['client_fingerprint', 'accessed_at']);
+      table.index(['client_ip', 'accessed_at']);
+    });
+  }
+  
+  // Add protection settings to app_settings
+  const protectionSettingExists = await knex('app_settings')
+    .where('setting_key', 'default_protection_level')
+    .first();
+    
+  if (!protectionSettingExists) {
+    await knex('app_settings').insert([
+      {
+        setting_key: 'default_protection_level',
+        setting_value: JSON.stringify('standard'),
+        setting_type: 'security'
+      },
+      {
+        setting_key: 'default_image_quality',
+        setting_value: JSON.stringify(85),
+        setting_type: 'security'
+      },
+      {
+        setting_key: 'enable_devtools_protection',
+        setting_value: JSON.stringify(true),
+        setting_type: 'security'
+      },
+      {
+        setting_key: 'max_image_requests_per_minute',
+        setting_value: JSON.stringify(30),
+        setting_type: 'security'
+      },
+      {
+        setting_key: 'suspicious_activity_threshold',
+        setting_value: JSON.stringify(10),
+        setting_type: 'security'
+      },
+      {
+        setting_key: 'enable_canvas_rendering',
+        setting_value: JSON.stringify(false),
+        setting_type: 'security'
+      },
+      {
+        setting_key: 'default_fragmentation_level',
+        setting_value: JSON.stringify(3),
+        setting_type: 'security'
+      }
+    ]);
+  }
+  
+  console.log('Enhanced image protection features added successfully');
+};
+
+exports.down = async function(knex) {
+  console.log('Removing enhanced image protection features...');
+  
+  // Remove app settings
+  await knex('app_settings')
+    .whereIn('setting_key', [
+      'default_protection_level',
+      'default_image_quality',
+      'enable_devtools_protection',
+      'max_image_requests_per_minute',
+      'suspicious_activity_threshold',
+      'enable_canvas_rendering',
+      'default_fragmentation_level'
+    ])
+    .delete();
+  
+  // Drop image access logs table
+  const hasImageAccessLogs = await knex.schema.hasTable('image_access_logs');
+  if (hasImageAccessLogs) {
+    await knex.schema.dropTable('image_access_logs');
+  }
+  
+  // Remove protection columns from events table
+  const hasProtectionLevel = await knex.schema.hasColumn('events', 'protection_level');
+  if (hasProtectionLevel) {
+    await knex.schema.table('events', (table) => {
+      table.dropColumn('protection_level');
+      table.dropColumn('image_quality');
+      table.dropColumn('add_fingerprint');
+      table.dropColumn('enable_devtools_protection');
+      table.dropColumn('use_canvas_rendering');
+      table.dropColumn('fragmentation_level');
+      table.dropColumn('overlay_protection');
+    });
+  }
+  
+  console.log('Enhanced image protection features removed');
+};

backend/migrations/core/039_add_security_logging.js

@@ -0,0 +1,117 @@
+// Add security logging and monitoring tables
+
+exports.up = async function(knex) {
+  console.log('Adding security logging and monitoring tables...');
+  
+  // Create security logs table for general security events
+  const hasSecurityLogs = await knex.schema.hasTable('security_logs');
+  if (!hasSecurityLogs) {
+    await knex.schema.createTable('security_logs', (table) => {
+      table.increments('id').primary();
+      table.string('event_type', 50).notNullable(); // rate_limit_exceeded, suspicious_activity, etc.
+      table.string('client_ip', 45).notNullable();
+      table.string('client_fingerprint', 32);
+      table.text('user_agent');
+      table.string('request_path');
+      table.string('request_method', 10);
+      table.json('details'); // Additional event details
+      table.timestamp('timestamp').defaultTo(knex.fn.now());
+      
+      // Indexes for performance
+      table.index(['event_type', 'timestamp']);
+      table.index(['client_ip', 'timestamp']);
+      table.index(['client_fingerprint', 'timestamp']);
+    });
+  }
+  
+  // Add security monitoring settings to app_settings
+  const securitySettings = [
+    {
+      setting_key: 'security_monitoring_enabled',
+      setting_value: JSON.stringify(true),
+      setting_type: 'security'
+    },
+    {
+      setting_key: 'max_image_requests_per_5_minutes',
+      setting_value: JSON.stringify(100),
+      setting_type: 'security'
+    },
+    {
+      setting_key: 'max_image_requests_per_hour',
+      setting_value: JSON.stringify(500),
+      setting_type: 'security'
+    },
+    {
+      setting_key: 'block_suspicious_ips',
+      setting_value: JSON.stringify(true),
+      setting_type: 'security'
+    },
+    {
+      setting_key: 'log_security_events_to_db',
+      setting_value: JSON.stringify(true),
+      setting_type: 'security'
+    },
+    {
+      setting_key: 'auto_block_threshold',
+      setting_value: JSON.stringify(5),
+      setting_type: 'security'
+    }
+  ];
+
+  for (const setting of securitySettings) {
+    const exists = await knex('app_settings')
+      .where('setting_key', setting.setting_key)
+      .first();
+      
+    if (!exists) {
+      await knex('app_settings').insert(setting);
+    }
+  }
+  
+  // Add mime_type column to photos table if it doesn't exist
+  const hasMimeType = await knex.schema.hasColumn('photos', 'mime_type');
+  if (!hasMimeType) {
+    await knex.schema.table('photos', (table) => {
+      table.string('mime_type', 100);
+    });
+    
+    // Update existing photos with default mime type
+    await knex('photos')
+      .whereNull('mime_type')
+      .update({ mime_type: 'image/jpeg' });
+  }
+  
+  console.log('Security logging and monitoring tables added successfully');
+};
+
+exports.down = async function(knex) {
+  console.log('Removing security logging and monitoring tables...');
+  
+  // Remove security settings
+  await knex('app_settings')
+    .whereIn('setting_key', [
+      'security_monitoring_enabled',
+      'max_image_requests_per_5_minutes', 
+      'max_image_requests_per_hour',
+      'block_suspicious_ips',
+      'log_security_events_to_db',
+      'auto_block_threshold'
+    ])
+    .delete();
+  
+  // Drop security logs table
+  const hasSecurityLogs = await knex.schema.hasTable('security_logs');
+  if (hasSecurityLogs) {
+    await knex.schema.dropTable('security_logs');
+  }
+  
+  // Remove mime_type column from photos table
+  const hasMimeType = await knex.schema.hasColumn('photos', 'mime_type');
+  if (hasMimeType) {
+    await knex.schema.table('photos', (table) => {
+      table.dropColumn('mime_type');
+    });
+  }
+  
+  console.log('Security logging and monitoring tables removed');
+};

backend/migrations/core/040_add_thumbnail_settings.js

@@ -0,0 +1,33 @@
+exports.up = async function(knex) {
+  // Add thumbnail settings to app_settings table
+  const thumbnailSettings = [
+    { setting_key: 'thumbnail_width', setting_value: 300, setting_type: 'number' },
+    { setting_key: 'thumbnail_height', setting_value: 300, setting_type: 'number' },
+    { setting_key: 'thumbnail_fit', setting_value: JSON.stringify('cover'), setting_type: 'string' },
+    { setting_key: 'thumbnail_quality', setting_value: 85, setting_type: 'number' },
+    { setting_key: 'thumbnail_format', setting_value: JSON.stringify('jpeg'), setting_type: 'string' }
+  ];
+
+  for (const setting of thumbnailSettings) {
+    const exists = await knex('app_settings').where('setting_key', setting.setting_key).first();
+    if (!exists) {
+      await knex('app_settings').insert({
+        ...setting,
+        updated_at: knex.fn.now()
+      });
+    }
+  }
+};
+
+exports.down = async function(knex) {
+  // Remove thumbnail settings
+  await knex('app_settings')
+    .whereIn('setting_key', [
+      'thumbnail_width',
+      'thumbnail_height', 
+      'thumbnail_fit',
+      'thumbnail_quality',
+      'thumbnail_format'
+    ])
+    .del();
+};

backend/migrations/core/041_add_external_media.js

@@ -0,0 +1,54 @@
+/**
+ * Migration 041: Add external media reference support
+ * - events.source_mode: 'managed' | 'reference'
+ * - events.external_path: relative path under external media root
+ * - photos.source_origin: 'managed' | 'external'
+ * - photos.external_relpath: relative path within event.external_path
+ */
+
+const { addColumnIfNotExists } = require('../helpers');
+
+exports.up = async function(knex) {
+  console.log('Running migration: 041_add_external_media');
+
+  // events.source_mode (default 'managed')
+  await addColumnIfNotExists(knex, 'events', 'source_mode', (table) => {
+    table.string('source_mode').notNullable().defaultTo('managed');
+  });
+
+  // events.external_path (nullable)
+  await addColumnIfNotExists(knex, 'events', 'external_path', (table) => {
+    table.text('external_path');
+  });
+
+  // photos.source_origin (default 'managed')
+  await addColumnIfNotExists(knex, 'photos', 'source_origin', (table) => {
+    table.string('source_origin').notNullable().defaultTo('managed');
+  });
+
+  // photos.external_relpath (nullable)
+  await addColumnIfNotExists(knex, 'photos', 'external_relpath', (table) => {
+    table.text('external_relpath');
+  });
+
+  // Helpful index for queries
+  try {
+    if (knex.client.config.client === 'pg') {
+      await knex.raw("CREATE INDEX IF NOT EXISTS photos_event_source_idx ON photos (event_id, source_origin)");
+    } else {
+      await knex.schema.alterTable('photos', (table) => {
+        table.index(['event_id', 'source_origin'], 'photos_event_source_idx');
+      });
+    }
+  } catch (e) {
+    console.log('Index creation skipped or failed (may already exist):', e.message);
+  }
+
+  console.log('Migration 041_add_external_media completed');
+};
+
+exports.down = async function(knex) {
+  console.log('Rollback: 041_add_external_media');
+  // Keep columns (safe rollback not removing data). Intentionally no-op.
+};
+

backend/migrations/legacy/004_add_categories_and_cms.js

@@ -0,0 +1,125 @@
+const { db } = require('../../src/database/db');
+
+async function up() {
+  console.log('Adding photo categories and CMS tables...');
+  
+  // Check if tables already exist
+  const hasPhotoCategoriesTable = await db.schema.hasTable('photo_categories');
+  const hasCmsPagesTable = await db.schema.hasTable('cms_pages');
+  const hasCategoryIdColumn = await db.schema.hasColumn('photos', 'category_id');
+  const hasLanguageColumn = await db.schema.hasColumn('admin_users', 'language');
+  
+  // Create photo_categories table
+  if (!hasPhotoCategoriesTable) {
+    await db.schema.createTable('photo_categories', (table) => {
+      table.increments('id').primary();
+      table.string('name', 100).notNullable();
+      table.string('slug', 100).notNullable();
+      table.boolean('is_global').defaultTo(true);
+      table.integer('event_id').references('id').inTable('events').onDelete('CASCADE');
+      table.timestamp('created_at').defaultTo(db.fn.now());
+      
+      // Unique constraint for slug within event scope
+      table.unique(['slug', 'event_id']);
+    });
+  }
+
+  // Create cms_pages table
+  if (!hasCmsPagesTable) {
+    await db.schema.createTable('cms_pages', (table) => {
+      table.increments('id').primary();
+      table.string('slug', 100).unique().notNullable();
+      table.text('title_en');
+      table.text('title_de');
+      table.text('content_en');
+      table.text('content_de');
+      table.timestamp('updated_at').defaultTo(db.fn.now());
+    });
+  }
+
+  // Add category_id to photos table
+  if (!hasCategoryIdColumn) {
+    await db.schema.alterTable('photos', (table) => {
+      table.integer('category_id').references('id').inTable('photo_categories');
+    });
+  }
+
+  // Add language preference to admin_users
+  if (!hasLanguageColumn) {
+    await db.schema.alterTable('admin_users', (table) => {
+      table.string('language', 2).defaultTo('en');
+    });
+  }
+
+  // Add language preference to app_settings for global default
+  const hasDefaultLanguageSetting = await db('app_settings')
+    .where('setting_key', 'default_language')
+    .first();
+    
+  if (!hasDefaultLanguageSetting) {
+    await db('app_settings').insert({
+      setting_key: 'default_language',
+      setting_value: JSON.stringify('en'),
+      setting_type: 'general',
+      updated_at: new Date()
+    });
+  }
+
+  // Insert default global categories
+  if (!hasPhotoCategoriesTable) {
+    const defaultCategories = [
+      { name: 'Ceremony', slug: 'ceremony', is_global: true },
+      { name: 'Reception', slug: 'reception', is_global: true },
+      { name: 'Portraits', slug: 'portraits', is_global: true },
+      { name: 'Group Photos', slug: 'group-photos', is_global: true },
+      { name: 'Details', slug: 'details', is_global: true },
+      { name: 'Party', slug: 'party', is_global: true }
+    ];
+
+    await db('photo_categories').insert(defaultCategories);
+  }
+
+  // Insert default legal pages
+  if (!hasCmsPagesTable) {
+    await db('cms_pages').insert([
+      {
+        slug: 'impressum',
+        title_en: 'Legal Notice',
+        title_de: 'Impressum',
+        content_en: '<h2>Legal Notice</h2><p>Please edit this content in the admin panel.</p>',
+        content_de: '<h2>Impressum</h2><p>Bitte bearbeiten Sie diesen Inhalt im Admin-Panel.</p>',
+        updated_at: new Date()
+      },
+      {
+        slug: 'datenschutz',
+        title_en: 'Privacy Policy',
+        title_de: 'Datenschutzerklärung',
+        content_en: '<h2>Privacy Policy</h2><p>Please edit this content in the admin panel.</p>',
+        content_de: '<h2>Datenschutzerklärung</h2><p>Bitte bearbeiten Sie diesen Inhalt im Admin-Panel.</p>',
+        updated_at: new Date()
+      }
+    ]);
+  }
+
+  console.log('Photo categories and CMS tables created successfully');
+}
+
+async function down() {
+  // Remove language from app_settings
+  await db('app_settings').where('setting_key', 'default_language').delete();
+  
+  // Drop columns
+  await db.schema.alterTable('admin_users', (table) => {
+    table.dropColumn('language');
+  });
+  
+  await db.schema.alterTable('photos', (table) => {
+    table.dropColumn('category_id');
+  });
+  
+  // Drop tables
+  await db.schema.dropTableIfExists('cms_pages');
+  await db.schema.dropTableIfExists('photo_categories');
+}
+
+module.exports = { up, down };

backend/migrations/legacy/014_add_default_welcome_message.js

@@ -8,8 +8,7 @@ exports.up = async function(knex) {
     await knex('app_settings').insert({
       setting_key: 'general_default_welcome_message',
       setting_value: JSON.stringify('Thank you for using our photo sharing service! We hope you enjoy your photos.'),
-      setting_type: 'general',
-      updated_at: new Date()
+      setting_type: 'general'
     });
   }
 

backend/migrations/legacy/014_add_host_name_to_events_duplicate.js

@@ -1,4 +1,4 @@
-const { db } = require('../src/database/db');
+const { db } = require('../../src/database/db');
 
 async function up() {
   // Check if host_name column already exists

backend/migrations/legacy/015_add_login_attempts_table.js

@@ -0,0 +1,23 @@
+exports.up = async function(knex) {
+  const hasLoginAttemptsTable = await knex.schema.hasTable('login_attempts');
+  
+  if (!hasLoginAttemptsTable) {
+    return knex.schema.createTable('login_attempts', table => {
+      table.increments('id').primary();
+      table.string('identifier').notNullable(); // username or email
+      table.string('ip_address', 45).notNullable(); // IPv4 or IPv6
+      table.text('user_agent');
+      table.timestamp('attempt_time').defaultTo(knex.fn.now());
+      table.boolean('success').defaultTo(false);
+      
+      // Indexes for performance
+      table.index('identifier');
+      table.index('attempt_time');
+      table.index(['identifier', 'success', 'attempt_time']);
+    });
+  }
+};
+
+exports.down = function(knex) {
+  return knex.schema.dropTableIfExists('login_attempts');
+};

backend/migrations/legacy/016_add_auth_security_columns.js

@@ -0,0 +1,36 @@
+exports.up = async function(knex) {
+  // Check if columns already exist to avoid conflicts
+  const hasPasswordChangedAt = await knex.schema.hasColumn('admin_users', 'password_changed_at');
+  const hasLastLoginIp = await knex.schema.hasColumn('admin_users', 'last_login_ip');
+  const hasTwoFactorEnabled = await knex.schema.hasColumn('admin_users', 'two_factor_enabled');
+  const hasTwoFactorSecret = await knex.schema.hasColumn('admin_users', 'two_factor_secret');
+  
+  return knex.schema.table('admin_users', table => {
+    // Add password change tracking
+    if (!hasPasswordChangedAt) {
+      table.timestamp('password_changed_at').nullable();
+    }
+    
+    // Add last login IP for security monitoring  
+    if (!hasLastLoginIp) {
+      table.string('last_login_ip', 45).nullable();
+    }
+    
+    // Add account security flags
+    if (!hasTwoFactorEnabled) {
+      table.boolean('two_factor_enabled').defaultTo(false);
+    }
+    if (!hasTwoFactorSecret) {
+      table.string('two_factor_secret').nullable();
+    }
+  });
+};
+
+exports.down = function(knex) {
+  return knex.schema.table('admin_users', table => {
+    table.dropColumn('password_changed_at');
+    table.dropColumn('last_login_ip');
+    table.dropColumn('two_factor_enabled');
+    table.dropColumn('two_factor_secret');
+  });
+};

backend/migrations/legacy/017_add_token_revocation_tables.js

@@ -0,0 +1,63 @@
+exports.up = async function(knex) {
+  // Check if tables already exist to avoid conflicts
+  const hasRevokedTokensTable = await knex.schema.hasTable('revoked_tokens');
+  const hasUserTokenRevocationsTable = await knex.schema.hasTable('user_token_revocations');
+  
+  // Create revoked_tokens table if it doesn't exist
+  if (!hasRevokedTokensTable) {
+    await knex.schema.createTable('revoked_tokens', table => {
+      table.increments('id').primary();
+      table.string('token_id').notNullable().unique(); // JWT ID or generated ID
+      table.integer('user_id').nullable(); // User who owned the token
+      table.string('token_type', 20); // admin, gallery, etc.
+      table.timestamp('revoked_at').defaultTo(knex.fn.now());
+      table.timestamp('expires_at').notNullable(); // When token would have expired
+      table.string('reason', 100); // password_change, logout, compromised, etc.
+      table.text('metadata'); // Additional JSON data
+      
+      // Indexes for performance
+      table.index('token_id');
+      table.index('user_id');
+      table.index('expires_at'); // For cleanup
+    });
+  }
+  
+  // Create user_token_revocations table if it doesn't exist
+  if (!hasUserTokenRevocationsTable) {
+    await knex.schema.createTable('user_token_revocations', table => {
+      table.integer('user_id').primary();
+      table.timestamp('revoked_at').notNullable();
+      table.string('reason', 100);
+      
+      // Index for quick lookups
+      table.index('revoked_at');
+    });
+  }
+  
+  // Add any missing indexes if tables already existed
+  if (hasRevokedTokensTable) {
+    try {
+      // Try to add indexes if they don't exist (PostgreSQL syntax)
+      await knex.raw('CREATE INDEX IF NOT EXISTS "revoked_tokens_token_id_index" ON "revoked_tokens" ("token_id")');
+      await knex.raw('CREATE INDEX IF NOT EXISTS "revoked_tokens_user_id_index" ON "revoked_tokens" ("user_id")');
+      await knex.raw('CREATE INDEX IF NOT EXISTS "revoked_tokens_expires_at_index" ON "revoked_tokens" ("expires_at")');
+    } catch (error) {
+      // For SQLite compatibility, ignore errors if indexes already exist
+      console.log('Note: Some indexes may already exist, continuing...');
+    }
+  }
+  
+  if (hasUserTokenRevocationsTable) {
+    try {
+      await knex.raw('CREATE INDEX IF NOT EXISTS "user_token_revocations_revoked_at_index" ON "user_token_revocations" ("revoked_at")');
+    } catch (error) {
+      console.log('Note: Some indexes may already exist, continuing...');
+    }
+  }
+};
+
+exports.down = function(knex) {
+  return knex.schema
+    .dropTableIfExists('user_token_revocations')
+    .dropTableIfExists('revoked_tokens');
+};

backend/migrations/legacy/027_add_rate_limit_settings_duplicate.js

@@ -41,8 +41,7 @@ exports.up = async function(knex) {
     
     if (!exists) {
       await knex('app_settings').insert({
-        ...setting,
-        updated_at: knex.fn.now()
+        ...setting
       });
     }
   }

backend/migrations/run-migrations-safe.js

@@ -27,8 +27,12 @@ async function isMigrationApplied(filename) {
 
 // Mark migration as applied without running it (for existing schema)
 async function markMigrationAsApplied(filename) {
-  await db('migrations').insert({ filename });
-  console.log(`Marked migration ${filename} as applied`);
+  // Check if already marked to avoid duplicate key error
+  const isApplied = await isMigrationApplied(filename);
+  if (!isApplied) {
+    await db('migrations').insert({ filename });
+    console.log(`Marked migration ${filename} as applied`);
+  }
 }
 
 // Detect existing schema and mark migrations as applied
@@ -36,12 +40,14 @@ async function detectExistingSchema() {
   console.log('Detecting existing schema...');
   
   const tableChecks = [
-    { table: 'events', migration: 'init.js' },
-    { table: 'photos', migration: 'init.js' },
+    { table: 'events', migration: '001_init.js' },
+    { table: 'photos', migration: '001_init.js' },
     { table: 'photo_categories', migration: '004_add_categories_and_cms.js' },
     { table: 'cms_pages', migration: '004_add_categories_and_cms.js' },
     { table: 'login_attempts', migration: '015_add_login_attempts_table.js' },
     { table: 'token_blacklist', migration: '017_add_token_revocation_tables.js' },
+    { table: 'backup_runs', migration: '029_add_backup_service_tables.js' },
+    { table: 'gallery_feedback', migration: '033_add_gallery_feedback.js' },
   ];
   
   for (const check of tableChecks) {
@@ -56,13 +62,14 @@ async function detectExistingSchema() {
 }
 
 // Run a single migration safely
-async function runMigrationSafely(filename) {
+async function runMigrationSafely(filepath) {
   try {
-    const migrationPath = path.join(__dirname, filename);
+    const migrationPath = path.join(__dirname, filepath);
     const migration = require(migrationPath);
+    const filename = path.basename(filepath);
     
     if (migration.up) {
-      console.log(`Running migration: ${filename}`);
+      console.log(`Running migration: ${filepath}`);
       
       // Run migration in a transaction if possible
       if (db.client.config.client === 'pg') {
@@ -74,14 +81,14 @@ async function runMigrationSafely(filename) {
       }
       
       await db('migrations').insert({ filename });
-      console.log(`Migration ${filename} completed successfully`);
+      console.log(`Migration ${filepath} completed successfully`);
     }
   } catch (error) {
     // Check if error is because schema already exists
     if (error.code === '42P07' || // PostgreSQL: relation already exists
         error.code === 'SQLITE_ERROR' && error.message.includes('already exists')) {
-      console.log(`Migration ${filename} - schema already exists, marking as applied`);
-      await markMigrationAsApplied(filename);
+      console.log(`Migration ${filepath} - schema already exists, marking as applied`);
+      await markMigrationAsApplied(path.basename(filepath));
     } else {
       throw error;
     }
@@ -101,26 +108,79 @@ async function runMigrations() {
     // Create migrations tracking table
     await ensureMigrationsTable();
     
-    // Detect and mark existing schema
-    await detectExistingSchema();
+    // Check if essential tables exist to determine if this is truly a new deployment
+    const hasEventsTable = await db.schema.hasTable('events');
+    const hasPhotosTable = await db.schema.hasTable('photos');
+    const hasAdminTable = await db.schema.hasTable('admin_users');
+    const hasActivityLogsTable = await db.schema.hasTable('activity_logs');
     
-    // Get all migration files
-    const files = await fs.readdir(__dirname);
-    const migrationFiles = files
-      .filter(f => f.match(/^\d{3}_.*\.js$/) || f === 'init.js')
-      .sort((a, b) => {
-        // Ensure init.js runs first
-        if (a === 'init.js') return -1;
-        if (b === 'init.js') return 1;
-        return a.localeCompare(b);
-      });
+    // Get applied migrations
+    const appliedMigrations = await db('migrations').select('filename');
+    const appliedFilenames = appliedMigrations.map(m => m.filename);
+    
+    // Check if this is a new deployment
+    // It's new if no essential tables exist OR no migrations have been applied
+    const isNewDeployment = (!hasEventsTable || !hasPhotosTable || !hasAdminTable || !hasActivityLogsTable) || appliedFilenames.length === 0;
+    
+    // Only detect existing schema for truly existing deployments
+    if (!isNewDeployment) {
+      await detectExistingSchema();
+    }
+    
+    // Get migration files from appropriate directories
+    let migrationFiles = [];
+    
+    if (isNewDeployment) {
+      // For new deployments, only run core migrations
+      console.log('New deployment detected - running core migrations only');
+      const coreDir = path.join(__dirname, 'core');
+      const coreFiles = await fs.readdir(coreDir);
+      migrationFiles = coreFiles
+        .filter(f => f.match(/^\d{3}_.*\.js$/))
+        .map(f => path.join('core', f))
+        .sort((a, b) => {
+          const baseA = path.basename(a);
+          const baseB = path.basename(b);
+          const numA = parseInt(baseA.split('_')[0]);
+          const numB = parseInt(baseB.split('_')[0]);
+          return numA - numB;
+        });
+    } else {
+      // For existing deployments, run all migrations (legacy + core)
+      console.log('Existing deployment detected - checking all migrations');
+      
+      // Get legacy migrations
+      const legacyDir = path.join(__dirname, 'legacy');
+      const legacyFiles = await fs.readdir(legacyDir);
+      const legacyMigrations = legacyFiles
+        .filter(f => f.match(/^\d{3}_.*\.js$/))
+        .map(f => path.join('legacy', f));
+      
+      // Get core migrations
+      const coreDir = path.join(__dirname, 'core');
+      const coreFiles = await fs.readdir(coreDir);
+      const coreMigrations = coreFiles
+        .filter(f => f.match(/^\d{3}_.*\.js$/))
+        .map(f => path.join('core', f));
+      
+      // Combine and sort by number
+      migrationFiles = [...legacyMigrations, ...coreMigrations]
+        .sort((a, b) => {
+          const baseA = path.basename(a);
+          const baseB = path.basename(b);
+          const numA = parseInt(baseA.split('_')[0]);
+          const numB = parseInt(baseB.split('_')[0]);
+          return numA - numB;
+        });
+    }
     
     // Run pending migrations
     let pendingCount = 0;
     let skippedCount = 0;
     
     for (const file of migrationFiles) {
-      const isApplied = await isMigrationApplied(file);
+      const filename = path.basename(file);
+      const isApplied = appliedFilenames.includes(filename);
       if (!isApplied) {
         await runMigrationSafely(file);
         pendingCount++;

backend/migrations/run-migrations.js

@@ -22,15 +22,16 @@ async function getAppliedMigrations() {
 }
 
 // Run a single migration
-async function runMigration(filename) {
-  const migrationPath = path.join(__dirname, filename);
+async function runMigration(filepath) {
+  const migrationPath = path.join(__dirname, filepath);
   const migration = require(migrationPath);
+  const filename = path.basename(filepath);
   
   if (migration.up) {
-    console.log(`Running migration: ${filename}`);
+    console.log(`Running migration: ${filepath}`);
     await migration.up(db);
     await db('migrations').insert({ filename });
-    console.log(`Migration ${filename} completed`);
+    console.log(`Migration ${filepath} completed`);
   }
 }
 
@@ -50,19 +51,62 @@ async function runMigrations() {
     // Create migrations table
     await createMigrationsTable();
     
-    // Get all migration files
-    const files = await fs.readdir(__dirname);
-    const migrationFiles = files
-      .filter(f => f.match(/^\d{3}_.*\.js$/))
-      .sort();
-    
     // Get applied migrations
     const appliedMigrations = await getAppliedMigrations();
     
+    // Check if this is a new deployment (no migrations have been applied)
+    const isNewDeployment = appliedMigrations.length === 0;
+    
+    // Get migration files from appropriate directories
+    let migrationFiles = [];
+    
+    if (isNewDeployment) {
+      // For new deployments, only run core migrations
+      console.log('New deployment detected - running core migrations only');
+      const coreDir = path.join(__dirname, 'core');
+      const coreFiles = await fs.readdir(coreDir);
+      migrationFiles = coreFiles
+        .filter(f => f.match(/^\d{3}_.*\.js$/))
+        .map(f => path.join('core', f))
+        .sort((a, b) => {
+          const baseA = path.basename(a);
+          const baseB = path.basename(b);
+          const numA = parseInt(baseA.split('_')[0]);
+          const numB = parseInt(baseB.split('_')[0]);
+          return numA - numB;
+        });
+    } else {
+      // For existing deployments, run all migrations (legacy + core)
+      console.log('Existing deployment detected - checking all migrations');
+      
+      // Get legacy migrations
+      const legacyDir = path.join(__dirname, 'legacy');
+      const legacyFiles = await fs.readdir(legacyDir);
+      const legacyMigrations = legacyFiles
+        .filter(f => f.match(/^\d{3}_.*\.js$/))
+        .map(f => path.join('legacy', f));
+      
+      // Get core migrations
+      const coreDir = path.join(__dirname, 'core');
+      const coreFiles = await fs.readdir(coreDir);
+      const coreMigrations = coreFiles
+        .filter(f => f.match(/^\d{3}_.*\.js$/))
+        .map(f => path.join('core', f));
+      
+      // Combine and sort by number
+      migrationFiles = [...legacyMigrations, ...coreMigrations]
+        .sort((a, b) => {
+          const numA = parseInt(path.basename(a).split('_')[0]);
+          const numB = parseInt(path.basename(b).split('_')[0]);
+          return numA - numB;
+        });
+    }
+    
     // Run pending migrations
     let pendingCount = 0;
     for (const file of migrationFiles) {
-      if (!appliedMigrations.includes(file)) {
+      const filename = path.basename(file);
+      if (!appliedMigrations.includes(filename)) {
         await runMigration(file);
         pendingCount++;
       }

backend/package.json

@@ -1,6 +1,6 @@
 {
   "name": "picpeak-backend",
-  "version": "1.0.65",
+  "version": "1.0.115",
   "description": "Backend for PicPeak event photo sharing platform",
   "main": "server.js",
   "scripts": {
@@ -8,36 +8,40 @@
     "dev": "nodemon server.js",
     "migrate": "node migrations/run-migrations.js",
     "migrate:safe": "node migrations/run-migrations-safe.js",
-    "fix-temp-photos": "node scripts/fix-temp-photos.js",
     "test": "jest",
     "lint": "eslint src/"
   },
   "dependencies": {
+    "@aws-sdk/client-s3": "^3.850.0",
+    "@aws-sdk/lib-storage": "^3.850.0",
+    "@aws-sdk/s3-request-presigner": "^3.850.0",
     "adm-zip": "^0.5.16",
     "archiver": "^5.3.1",
     "axios": "^1.10.0",
-    "bcrypt": "^5.1.0",
-    "chokidar": "^3.5.3",
+    "bcrypt": "6.0.0",
+    "chokidar": "4.0.3",
     "cors": "^2.8.5",
     "dotenv": "^16.0.3",
     "express": "^4.18.2",
     "express-rate-limit": "^6.7.0",
     "express-validator": "^7.0.1",
-    "form-data": "^4.0.3",
+    "form-data": "^4.0.4",
     "handlebars": "^4.7.8",
     "helmet": "^7.0.0",
-    "i18next": "^25.3.1",
+    "i18next": "25.3.2",
     "i18next-browser-languagedetector": "^8.2.0",
     "i18next-http-backend": "^3.0.2",
     "joi": "^17.9.1",
+    "js-yaml": "^4.1.0",
     "jsonwebtoken": "^9.0.0",
     "knex": "^2.4.2",
-    "multer": "^2.0.1",
+    "mime-types": "^3.0.1",
+    "multer": "^2.0.2",
     "node-cron": "^3.0.2",
-    "nodemailer": "^6.9.1",
+    "nodemailer": "7.0.5",
     "pg": "^8.16.3",
     "react-i18next": "^15.6.0",
-    "sharp": "^0.32.0",
+    "sharp": "0.34.3",
     "sqlite3": "^5.1.6",
     "uuid": "^11.1.0",
     "winston": "^3.8.2",

backend/scripts/check-db-issues.js

@@ -1,60 +0,0 @@
-require('dotenv').config();
-const { db } = require('../src/database/db');
-
-async function checkDatabaseIssues() {
-  console.log('Checking database issues...\n');
-  
-  try {
-    // Check email_templates table structure
-    console.log('1. Checking email_templates table structure:');
-    const emailTemplateColumns = await db('email_templates').columnInfo();
-    console.log('Columns:', Object.keys(emailTemplateColumns));
-    
-    // Check if any templates exist
-    const templateCount = await db('email_templates').count('* as count');
-    console.log('Template count:', templateCount[0].count);
-    
-    // Check for specific template
-    const galleryCreatedTemplate = await db('email_templates')
-      .where('template_key', 'gallery_created')
-      .first();
-    console.log('gallery_created template exists:', !!galleryCreatedTemplate);
-    
-    // Check activity_logs table
-    console.log('\n2. Checking activity_logs table:');
-    const activityLogColumns = await db('activity_logs').columnInfo();
-    console.log('Columns:', Object.keys(activityLogColumns));
-    
-    // Check migrations table
-    console.log('\n3. Checking migrations status:');
-    const migrations = await db('migrations')
-      .orderBy('id', 'desc')
-      .limit(10);
-    console.log('Latest migrations:');
-    migrations.forEach(m => console.log(`  - ${m.filename}`));
-    
-    // Test a simple query from notifications route
-    console.log('\n4. Testing notifications query:');
-    try {
-      const notifications = await db('activity_logs')
-        .select(
-          'activity_logs.*',
-          'events.event_name'
-        )
-        .leftJoin('events', 'activity_logs.event_id', 'events.id')
-        .orderBy('activity_logs.created_at', 'desc')
-        .limit(5);
-      console.log(`Found ${notifications.length} notifications`);
-    } catch (error) {
-      console.error('Notifications query failed:', error.message);
-    }
-    
-  } catch (error) {
-    console.error('Error:', error);
-  } finally {
-    await db.destroy();
-    process.exit(0);
-  }
-}
-
-checkDatabaseIssues();

backend/scripts/check-db-schema.js

@@ -1,42 +0,0 @@
-#!/usr/bin/env node
-
-const sqlite3 = require('sqlite3').verbose();
-
-// Connect to the database
-const dbPath = '/app/data/photo_sharing.db';
-console.log(`Connecting to database at: ${dbPath}`);
-
-const db = new sqlite3.Database(dbPath, sqlite3.OPEN_READONLY, (err) => {
-  if (err) {
-    console.error('Error opening database:', err.message);
-    process.exit(1);
-  }
-  console.log('Connected to the SQLite database.\n');
-});
-
-// Get schema for events table
-console.log('=== EVENTS TABLE SCHEMA ===');
-db.all("PRAGMA table_info(events)", [], (err, rows) => {
-  if (err) {
-    console.error('Error getting events schema:', err.message);
-  } else {
-    rows.forEach(row => {
-      console.log(`${row.name} (${row.type})`);
-    });
-  }
-  
-  console.log('\n=== PHOTOS TABLE SCHEMA ===');
-  // Get schema for photos table
-  db.all("PRAGMA table_info(photos)", [], (err, rows) => {
-    if (err) {
-      console.error('Error getting photos schema:', err.message);
-    } else {
-      rows.forEach(row => {
-        console.log(`${row.name} (${row.type})`);
-      });
-    }
-    
-    // Close the database
-    db.close();
-  });
-});

backend/scripts/check-email-environment.js

@@ -1,131 +0,0 @@
-const { db } = require('../src/database/db');
-
-async function checkEmailEnvironment() {
-  console.log('=== Email Environment Check ===\n');
-  
-  // 1. Check environment variables
-  console.log('1. Environment Variables:');
-  const envVars = [
-    'SMTP_HOST',
-    'SMTP_PORT',
-    'SMTP_USER',
-    'SMTP_PASS',
-    'SMTP_FROM',
-    'SMTP_SECURE',
-    'EMAIL_PROCESSOR_ENABLED',
-    'NODE_ENV'
-  ];
-  
-  envVars.forEach(varName => {
-    const value = process.env[varName];
-    if (varName.includes('PASS')) {
-      console.log(`   ${varName}: ${value ? '***' : 'NOT SET'}`);
-    } else {
-      console.log(`   ${varName}: ${value || 'NOT SET'}`);
-    }
-  });
-  
-  // 2. Check database configuration
-  console.log('\n2. Database Email Configuration:');
-  try {
-    const emailConfig = await db('email_configs').first();
-    if (emailConfig) {
-      console.log('   Email configuration found in database:');
-      console.log(`   - SMTP Host: ${emailConfig.smtp_host}`);
-      console.log(`   - SMTP Port: ${emailConfig.smtp_port}`);
-      console.log(`   - SMTP User: ${emailConfig.smtp_user || 'NOT SET'}`);
-      console.log(`   - SMTP Secure: ${emailConfig.smtp_secure}`);
-      console.log(`   - From Address: ${emailConfig.smtp_from}`);
-    } else {
-      console.log('   ⚠️  No email configuration found in database!');
-      console.log('   This will prevent the email processor from initializing.');
-    }
-  } catch (error) {
-    console.log(`   ❌ Error reading email configuration: ${error.message}`);
-  }
-  
-  // 3. Check if the email processor should be disabled
-  console.log('\n3. Email Processor Status:');
-  const isDisabled = process.env.EMAIL_PROCESSOR_ENABLED === 'false';
-  if (isDisabled) {
-    console.log('   ⚠️  Email processor is DISABLED via EMAIL_PROCESSOR_ENABLED=false');
-  } else {
-    console.log('   ✅ Email processor is enabled (default)');
-  }
-  
-  // 4. Check pending emails
-  console.log('\n4. Email Queue Status:');
-  try {
-    const pending = await db('email_queue')
-      .where('status', 'pending')
-      .count('* as count')
-      .first();
-    
-    const failed = await db('email_queue')
-      .where('status', 'failed')
-      .where('retry_count', '>=', 3)
-      .count('* as count')
-      .first();
-    
-    const sent = await db('email_queue')
-      .where('status', 'sent')
-      .count('* as count')
-      .first();
-    
-    console.log(`   - Pending emails: ${pending.count}`);
-    console.log(`   - Failed emails (max retries): ${failed.count}`);
-    console.log(`   - Sent emails: ${sent.count}`);
-  } catch (error) {
-    console.log(`   ❌ Error querying email queue: ${error.message}`);
-  }
-  
-  // 5. Test database connection
-  console.log('\n5. Database Connection:');
-  try {
-    await db.raw('SELECT 1');
-    console.log('   ✅ Database connection successful');
-  } catch (error) {
-    console.log(`   ❌ Database connection failed: ${error.message}`);
-  }
-  
-  // 6. Check for any recent errors
-  console.log('\n6. Recent Email Errors:');
-  try {
-    const recentErrors = await db('email_queue')
-      .whereNotNull('error_message')
-      .orderBy('id', 'desc')
-      .limit(3)
-      .select('id', 'email_type', 'error_message', 'retry_count');
-    
-    if (recentErrors.length > 0) {
-      recentErrors.forEach((email, index) => {
-        console.log(`   ${index + 1}. Email ID ${email.id} (${email.email_type}):`);
-        console.log(`      Retries: ${email.retry_count}`);
-        console.log(`      Error: ${email.error_message}`);
-      });
-    } else {
-      console.log('   No recent errors found');
-    }
-  } catch (error) {
-    console.log(`   ❌ Error querying recent errors: ${error.message}`);
-  }
-  
-  console.log('\n=== Environment check complete ===');
-  console.log('\nRecommendations:');
-  
-  const emailConfig = await db('email_configs').first().catch(() => null);
-  if (!emailConfig) {
-    console.log('❗ Configure email settings in the admin panel or add email_configs record');
-  }
-  
-  if (!process.env.SMTP_HOST && !emailConfig) {
-    console.log('❗ Set SMTP environment variables or configure in database');
-  }
-  
-  await db.destroy();
-}
-
-checkEmailEnvironment().catch(error => {
-  console.error('Fatal error:', error);
-  process.exit(1);
-});

backend/scripts/check-email-processor.js

@@ -1,157 +0,0 @@
-const { db } = require('../src/database/db');
-const winston = require('winston');
-
-// Create a simple console logger
-const logger = winston.createLogger({
-  format: winston.format.simple(),
-  transports: [new winston.transports.Console()]
-});
-
-async function checkEmailProcessor() {
-  try {
-    logger.info('=== Email Processor Diagnostic Check ===\n');
-    
-    // 1. Check pending emails
-    logger.info('1. Checking pending emails in queue...');
-    const pendingEmails = await db('email_queue')
-      .where('status', 'pending')
-      .where('retry_count', '<', 3)
-      .orderBy('created_at', 'asc');
-    
-    logger.info(`Found ${pendingEmails.length} pending emails\n`);
-    
-    if (pendingEmails.length > 0) {
-      logger.info('Pending email details:');
-      pendingEmails.forEach((email, index) => {
-        logger.info(`\nEmail ${index + 1}:`);
-        logger.info(`  ID: ${email.id}`);
-        logger.info(`  Type: ${email.email_type}`);
-        logger.info(`  Recipient: ${email.recipient_email}`);
-        logger.info(`  Event ID: ${email.event_id}`);
-        logger.info(`  Status: ${email.status}`);
-        logger.info(`  Retry Count: ${email.retry_count}`);
-        logger.info(`  Scheduled At: ${email.scheduled_at}`);
-        logger.info(`  Created At: ${email.created_at}`);
-        logger.info(`  Error: ${email.error_message || 'None'}`);
-        
-        // Check if email_data needs parsing
-        logger.info(`  Email Data Type: ${typeof email.email_data}`);
-        if (email.email_data) {
-          try {
-            const data = typeof email.email_data === 'string' 
-              ? JSON.parse(email.email_data) 
-              : email.email_data;
-            logger.info(`  Email Data Keys: ${Object.keys(data).join(', ')}`);
-          } catch (e) {
-            logger.error(`  Failed to parse email_data: ${e.message}`);
-          }
-        }
-      });
-    }
-    
-    // 2. Check failed emails
-    logger.info('\n\n2. Checking failed emails...');
-    const failedEmails = await db('email_queue')
-      .where('status', 'failed')
-      .orderBy('created_at', 'desc')
-      .limit(5);
-    
-    logger.info(`Found ${failedEmails.length} failed emails (showing last 5)\n`);
-    
-    if (failedEmails.length > 0) {
-      failedEmails.forEach((email, index) => {
-        logger.info(`\nFailed Email ${index + 1}:`);
-        logger.info(`  ID: ${email.id}`);
-        logger.info(`  Type: ${email.email_type}`);
-        logger.info(`  Retry Count: ${email.retry_count}`);
-        logger.info(`  Error: ${email.error_message || 'No error message'}`);
-        logger.info(`  Last Attempt: ${email.sent_at || 'Never'}`);
-      });
-    }
-    
-    // 3. Check if email processor should be running
-    logger.info('\n\n3. Checking email processor configuration...');
-    
-    // Check environment variables
-    const emailConfig = {
-      SMTP_HOST: process.env.SMTP_HOST,
-      SMTP_PORT: process.env.SMTP_PORT,
-      SMTP_USER: process.env.SMTP_USER,
-      SMTP_FROM: process.env.SMTP_FROM,
-      SMTP_SECURE: process.env.SMTP_SECURE,
-      EMAIL_PROCESSOR_ENABLED: process.env.EMAIL_PROCESSOR_ENABLED || 'true'
-    };
-    
-    logger.info('Email configuration:');
-    Object.entries(emailConfig).forEach(([key, value]) => {
-      if (key === 'SMTP_USER') {
-        logger.info(`  ${key}: ${value ? '***' : 'NOT SET'}`);
-      } else {
-        logger.info(`  ${key}: ${value || 'NOT SET'}`);
-      }
-    });
-    
-    // 4. Test email processor functionality
-    logger.info('\n\n4. Testing email processor functionality...');
-    
-    // Import the email processor
-    const { processEmailQueue, testEmailConnection } = require('../src/services/emailProcessor');
-    
-    // Test email connection
-    logger.info('Testing email connection...');
-    try {
-      const connectionTest = await testEmailConnection();
-      logger.info(`Email connection test: ${connectionTest ? 'SUCCESS' : 'FAILED'}`);
-    } catch (error) {
-      logger.error(`Email connection test failed: ${error.message}`);
-    }
-    
-    // Try to process queue once manually
-    if (pendingEmails.length > 0) {
-      logger.info('\n\n5. Attempting to process email queue manually...');
-      try {
-        await processEmailQueue();
-        logger.info('Manual queue processing completed');
-        
-        // Check status after processing
-        const stillPending = await db('email_queue')
-          .where('status', 'pending')
-          .where('retry_count', '<', 3)
-          .count('* as count')
-          .first();
-        
-        logger.info(`Emails still pending after processing: ${stillPending.count}`);
-      } catch (error) {
-        logger.error(`Error processing queue: ${error.message}`);
-        logger.error(`Stack trace: ${error.stack}`);
-      }
-    }
-    
-    // 5. Check for any recent successful emails
-    logger.info('\n\n6. Checking recent successful emails...');
-    const recentSuccess = await db('email_queue')
-      .where('status', 'sent')
-      .orderBy('sent_at', 'desc')
-      .limit(3);
-    
-    if (recentSuccess.length > 0) {
-      logger.info(`Last ${recentSuccess.length} successful emails:`);
-      recentSuccess.forEach((email, index) => {
-        logger.info(`  ${index + 1}. Type: ${email.email_type}, Sent: ${email.sent_at}`);
-      });
-    } else {
-      logger.info('No successfully sent emails found');
-    }
-    
-    logger.info('\n\n=== Diagnostic check complete ===');
-    
-  } catch (error) {
-    logger.error('Error running diagnostic check:', error);
-  } finally {
-    await db.destroy();
-    process.exit(0);
-  }
-}
-
-// Run the check
-checkEmailProcessor();

backend/scripts/check-email-templates.js

@@ -1,66 +0,0 @@
-const { db } = require('../src/database/db');
-
-async function checkEmailTemplates() {
-  try {
-    console.log('=== Email Templates Check ===\n');
-    
-    // 1. Check table columns
-    console.log('1. Checking email_templates table structure...');
-    
-    // Check which columns exist
-    const columnChecks = [
-      'subject', 'subject_en', 'subject_de',
-      'body_html', 'body_html_en', 'body_html_de',
-      'body_text', 'body_text_en', 'body_text_de'
-    ];
-    
-    const existingColumns = [];
-    for (const col of columnChecks) {
-      const exists = await db.schema.hasColumn('email_templates', col);
-      if (exists) existingColumns.push(col);
-    }
-    
-    console.log('   Existing columns:', existingColumns.join(', '));
-    
-    // 2. Get all templates
-    console.log('\n2. Current email templates:');
-    const templates = await db('email_templates').select('*');
-    
-    for (const template of templates) {
-      console.log(`\n   Template: ${template.template_key}`);
-      console.log('   -------------------');
-      
-      // Check which fields have content
-      const fields = ['subject', 'subject_en', 'subject_de', 
-                     'body_html', 'body_html_en', 'body_html_de',
-                     'body_text', 'body_text_en', 'body_text_de'];
-      
-      for (const field of fields) {
-        if (template[field]) {
-          const preview = template[field].substring(0, 50) + '...';
-          console.log(`   ${field}: ${preview}`);
-        }
-      }
-      
-      // Check for German translations
-      const hasGermanSubject = template.subject_de || template.body_html_de;
-      console.log(`   Has German translation: ${hasGermanSubject ? 'YES' : 'NO'}`);
-    }
-    
-    // 3. Summary
-    console.log('\n3. Summary:');
-    const totalTemplates = templates.length;
-    const templatesWithGerman = templates.filter(t => t.subject_de || t.body_html_de).length;
-    console.log(`   Total templates: ${totalTemplates}`);
-    console.log(`   Templates with German: ${templatesWithGerman}`);
-    console.log(`   Missing German: ${totalTemplates - templatesWithGerman}`);
-    
-    await db.destroy();
-  } catch (error) {
-    console.error('Error:', error);
-    await db.destroy();
-    process.exit(1);
-  }
-}
-
-checkEmailTemplates();

backend/scripts/check-german-templates.js

@@ -1,53 +0,0 @@
-const { db } = require('../src/database/db');
-
-async function checkGermanTemplates() {
-  try {
-    console.log('=== German Email Template Content Check ===\n');
-    
-    const templates = await db('email_templates').select('*');
-    
-    for (const template of templates) {
-      console.log(`\nTemplate: ${template.template_key}`);
-      console.log('=====================================');
-      
-      // Check German subject
-      console.log('\nGERMAN SUBJECT:');
-      console.log(template.subject_de || 'MISSING');
-      
-      // Check if German HTML body has English content
-      console.log('\nGERMAN HTML BODY:');
-      const germanHtml = template.body_html_de || '';
-      
-      // Check for English phrases in German template
-      const englishPhrases = [
-        'Dear', 'Gallery', 'has been', 'Your photo', 'successfully',
-        'Details:', 'Link:', 'Password:', 'Expires:', 'Event Date:',
-        'Thank you', 'Best regards', 'View Gallery', 'days'
-      ];
-      
-      const foundEnglish = englishPhrases.filter(phrase => 
-        germanHtml.toLowerCase().includes(phrase.toLowerCase())
-      );
-      
-      if (foundEnglish.length > 0) {
-        console.log('⚠️  Found English phrases in German template:', foundEnglish.join(', '));
-      }
-      
-      // Show first 500 chars of German HTML
-      console.log(germanHtml.substring(0, 500) + '...\n');
-      
-      // Check German text body
-      console.log('GERMAN TEXT BODY:');
-      const germanText = template.body_text_de || '';
-      console.log(germanText.substring(0, 300) + '...\n');
-    }
-    
-    await db.destroy();
-  } catch (error) {
-    console.error('Error:', error);
-    await db.destroy();
-    process.exit(1);
-  }
-}
-
-checkGermanTemplates();

backend/scripts/create-test-event.js

@@ -1,58 +0,0 @@
-const path = require('path');
-require('dotenv').config({ path: path.join(__dirname, '../.env') });
-const { db } = require('../src/database/db');
-const bcrypt = require('bcrypt');
-const jwt = require('jsonwebtoken');
-const { v4: uuidv4 } = require('uuid');
-
-async function createTestEvent() {
-  try {
-    console.log('Creating test event...');
-    
-    // Hash a simple password
-    const passwordHash = await bcrypt.hash('test123', 10);
-    
-    // Generate share token
-    const shareToken = uuidv4().replace(/-/g, '');
-    const shareLink = `http://localhost:3005/gallery/wedding-test123-2025-07-07/${shareToken}`;
-    
-    // Create event
-    const eventData = {
-      slug: 'wedding-test123-2025-07-07',
-      event_type: 'wedding',
-      event_name: 'Test Wedding',
-      event_date: '2025-07-07',
-      host_email: 'host@example.com',
-      admin_email: 'admin@example.com',
-      password_hash: passwordHash,
-      welcome_message: 'Welcome to our test wedding gallery!',
-      color_theme: null, // Use global theme
-      is_active: 1,
-      expires_at: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString(),
-      share_link: shareLink
-    };
-    
-    // Delete existing event if it exists
-    await db('events').where('slug', eventData.slug).delete();
-    
-    // Insert new event
-    const insertResult = await db('events').insert(eventData).returning('id');
-    const eventId = insertResult[0]?.id || insertResult[0];
-    console.log('Event created with ID:', eventId);
-    
-    console.log('\nTest event created successfully!');
-    console.log('Event details:');
-    console.log('- Name:', eventData.event_name);
-    console.log('- Slug:', eventData.slug);
-    console.log('- Password:', 'test123');
-    console.log('- Share link:', shareLink);
-    console.log('\nYou can now access the gallery at the share link above');
-    
-    process.exit(0);
-  } catch (error) {
-    console.error('Error creating test event:', error);
-    process.exit(1);
-  }
-}
-
-createTestEvent();

backend/scripts/debug-500-errors.js

@@ -1,92 +0,0 @@
-require('dotenv').config();
-const { db } = require('../src/database/db');
-
-async function debugEndpoints() {
-  console.log('Debugging 500 errors...\n');
-  
-  try {
-    // Test email templates query
-    console.log('1. Testing email templates query:');
-    try {
-      const templates = await db('email_templates')
-        .select('*')
-        .orderBy('template_key');
-      
-      console.log(`Found ${templates.length} templates`);
-      if (templates.length > 0) {
-        console.log('First template columns:', Object.keys(templates[0]));
-        console.log('Template keys:', templates.map(t => t.template_key));
-      }
-    } catch (error) {
-      console.error('Email templates query failed:', error.message);
-      console.error('Error code:', error.code);
-    }
-    
-    // Test notifications query
-    console.log('\n2. Testing notifications query:');
-    try {
-      const notifications = await db('activity_logs')
-        .select(
-          'activity_logs.*',
-          'events.event_name'
-        )
-        .leftJoin('events', 'activity_logs.event_id', 'events.id')
-        .whereNull('activity_logs.read_at')
-        .orderBy('activity_logs.created_at', 'desc')
-        .limit(5);
-      
-      console.log(`Found ${notifications.length} unread notifications`);
-    } catch (error) {
-      console.error('Notifications query failed:', error.message);
-      console.error('Error code:', error.code);
-      
-      // Check if it's a column issue
-      if (error.message.includes('column')) {
-        console.log('\nChecking activity_logs columns:');
-        const columns = await db('activity_logs').columnInfo();
-        console.log('Columns:', Object.keys(columns));
-      }
-    }
-    
-    // Test specific template query
-    console.log('\n3. Testing specific template query (gallery_created):');
-    try {
-      const template = await db('email_templates')
-        .where('template_key', 'gallery_created')
-        .first();
-      
-      if (template) {
-        console.log('Template found:', template.template_key);
-        console.log('Has subject_en?', template.subject_en !== undefined);
-        console.log('Has subject?', template.subject !== undefined);
-      } else {
-        console.log('Template not found');
-      }
-    } catch (error) {
-      console.error('Template query failed:', error.message);
-    }
-    
-    // Check CMS pages
-    console.log('\n4. Checking CMS pages:');
-    try {
-      const pages = await db('cms_pages')
-        .select('slug', 'title', 'is_published')
-        .orderBy('slug');
-      
-      console.log(`Found ${pages.length} CMS pages:`);
-      pages.forEach(page => {
-        console.log(`  - ${page.slug}: ${page.title} (published: ${page.is_published})`);
-      });
-    } catch (error) {
-      console.error('CMS pages query failed:', error.message);
-    }
-    
-  } catch (error) {
-    console.error('General error:', error);
-  } finally {
-    await db.destroy();
-    process.exit(0);
-  }
-}
-
-debugEndpoints();

backend/scripts/debug-email-queue.js

@@ -1,146 +0,0 @@
-const { db } = require('../src/database/db');
-const winston = require('winston');
-
-// Create a simple console logger
-const logger = winston.createLogger({
-  format: winston.format.simple(),
-  transports: [new winston.transports.Console()]
-});
-
-async function debugEmailQueue() {
-  try {
-    logger.info('=== Email Queue Debug Report ===\n');
-    
-    // 1. Count exactly like the admin dashboard does
-    logger.info('1. Admin Dashboard Query (ALL pending, no retry filter):');
-    const [adminCount] = await db('email_queue').where('status', 'pending').count('* as count');
-    logger.info(`   Pending emails (admin dashboard view): ${adminCount.count}\n`);
-    
-    // 2. Count like the email processor does
-    logger.info('2. Email Processor Query (pending with retry_count < 3):');
-    const [processorCount] = await db('email_queue')
-      .where('status', 'pending')
-      .where('retry_count', '<', 3)
-      .count('* as count');
-    logger.info(`   Pending emails (processor view): ${processorCount.count}\n`);
-    
-    // 3. Show the discrepancy
-    logger.info('3. Discrepancy Analysis:');
-    if (adminCount.count !== processorCount.count) {
-      logger.info(`   ⚠️  DISCREPANCY FOUND!`);
-      logger.info(`   Admin shows: ${adminCount.count}`);
-      logger.info(`   Processor will process: ${processorCount.count}`);
-      logger.info(`   Difference: ${adminCount.count - processorCount.count} email(s)\n`);
-      
-      // Find the problematic emails
-      logger.info('4. Emails with retry_count >= 3 (still pending):');
-      const stuckEmails = await db('email_queue')
-        .where('status', 'pending')
-        .where('retry_count', '>=', 3)
-        .select('*');
-      
-      if (stuckEmails.length > 0) {
-        logger.info(`   Found ${stuckEmails.length} stuck email(s):\n`);
-        stuckEmails.forEach((email, index) => {
-          logger.info(`   Email ${index + 1}:`);
-          logger.info(`     ID: ${email.id}`);
-          logger.info(`     Type: ${email.email_type}`);
-          logger.info(`     Recipient: ${email.recipient_email}`);
-          logger.info(`     Status: ${email.status}`);
-          logger.info(`     Retry Count: ${email.retry_count} ⚠️`);
-          logger.info(`     Created: ${email.created_at}`);
-          logger.info(`     Last Error: ${email.error_message || 'None'}\n`);
-        });
-      }
-    } else {
-      logger.info(`   ✅ No discrepancy - counts match\n`);
-    }
-    
-    // 5. Show ALL pending emails with details
-    logger.info('5. ALL Pending Emails (regardless of retry count):');
-    const allPending = await db('email_queue')
-      .where('status', 'pending')
-      .orderBy('retry_count', 'desc')
-      .orderBy('created_at', 'asc');
-    
-    if (allPending.length > 0) {
-      allPending.forEach((email, index) => {
-        const willProcess = email.retry_count < 3;
-        logger.info(`\n   Email ${index + 1}: ${willProcess ? '✅ WILL PROCESS' : '❌ STUCK (max retries)'}`);
-        logger.info(`     ID: ${email.id}`);
-        logger.info(`     Type: ${email.email_type}`);
-        logger.info(`     Recipient: ${email.recipient_email}`);
-        logger.info(`     Event ID: ${email.event_id}`);
-        logger.info(`     Retry Count: ${email.retry_count}/3`);
-        logger.info(`     Created: ${email.created_at}`);
-        logger.info(`     Scheduled: ${email.scheduled_at}`);
-        if (email.error_message) {
-          logger.info(`     Last Error: ${email.error_message}`);
-        }
-      });
-    } else {
-      logger.info('   No pending emails found');
-    }
-    
-    // 6. Show counts by status
-    logger.info('\n\n6. Email Queue Summary by Status:');
-    const statusCounts = await db('email_queue')
-      .select('status')
-      .count('* as count')
-      .groupBy('status')
-      .orderBy('status');
-    
-    statusCounts.forEach(row => {
-      logger.info(`   ${row.status}: ${row.count}`);
-    });
-    
-    // 7. Failed emails summary
-    logger.info('\n7. Failed Emails Summary:');
-    const failedSummary = await db('email_queue')
-      .where('status', 'failed')
-      .select('retry_count')
-      .count('* as count')
-      .groupBy('retry_count')
-      .orderBy('retry_count');
-    
-    if (failedSummary.length > 0) {
-      failedSummary.forEach(row => {
-        logger.info(`   Retry count ${row.retry_count}: ${row.count} email(s)`);
-      });
-    } else {
-      logger.info('   No failed emails');
-    }
-    
-    // 8. Recommendations
-    logger.info('\n\n=== RECOMMENDATIONS ===');
-    
-    if (adminCount.count > processorCount.count) {
-      logger.info('\n❗ You have emails stuck with retry_count >= 3');
-      logger.info('   These emails will NOT be processed automatically.');
-      logger.info('\n   To fix this, you can:');
-      logger.info('   1. Reset retry count: UPDATE email_queue SET retry_count = 0 WHERE status = \'pending\' AND retry_count >= 3;');
-      logger.info('   2. Mark as failed: UPDATE email_queue SET status = \'failed\' WHERE status = \'pending\' AND retry_count >= 3;');
-      logger.info('   3. Delete them: DELETE FROM email_queue WHERE status = \'pending\' AND retry_count >= 3;');
-    }
-    
-    const anyPending = adminCount.count > 0;
-    if (anyPending && processorCount.count === 0) {
-      logger.info('\n❗ All pending emails have exceeded retry limit');
-      logger.info('   The email processor will not attempt to send them.');
-    } else if (anyPending && processorCount.count > 0) {
-      logger.info('\n✅ Email processor should process the pending emails on next run');
-      logger.info('   Make sure the email processor service is running.');
-    }
-    
-    logger.info('\n=== Debug report complete ===');
-    
-  } catch (error) {
-    logger.error('Error running debug report:', error);
-  } finally {
-    await db.destroy();
-    process.exit(0);
-  }
-}
-
-// Run the debug
-debugEmailQueue();

backend/scripts/diagnose-thumbnails.js

@@ -1,132 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Script to diagnose thumbnail serving issues
- * Usage: node scripts/diagnose-thumbnails.js <eventId>
- */
-
-const path = require('path');
-const fs = require('fs').promises;
-const { db } = require('../src/database/db');
-
-const STORAGE_PATH = process.env.STORAGE_PATH || path.join(__dirname, '../../storage');
-const THUMBNAILS_DIR = path.join(STORAGE_PATH, 'thumbnails');
-
-async function diagnoseThumbnails(eventId) {
-  if (!eventId) {
-    console.error('Usage: node scripts/diagnose-thumbnails.js <eventId>');
-    process.exit(1);
-  }
-  
-  console.log(`Diagnosing thumbnails for event ID: ${eventId}`);
-  console.log(`Storage path: ${STORAGE_PATH}`);
-  console.log(`Thumbnails directory: ${THUMBNAILS_DIR}\n`);
-  
-  try {
-    // Get event info
-    const event = await db('events').where('id', eventId).first();
-    if (!event) {
-      console.error(`Event not found with ID: ${eventId}`);
-      return;
-    }
-    
-    console.log(`Event: ${event.event_name} (${event.slug})`);
-    console.log(`Active: ${event.is_active}, Archived: ${event.is_archived}\n`);
-    
-    // Get photos for this event
-    const photos = await db('photos')
-      .where('event_id', eventId)
-      .select('id', 'filename', 'path', 'thumbnail_path');
-    
-    console.log(`Found ${photos.length} photos in database\n`);
-    
-    let missingThumbnails = 0;
-    let existingThumbnails = 0;
-    let pathIssues = [];
-    
-    for (const photo of photos.slice(0, 10)) { // Check first 10 photos
-      console.log(`Photo ID ${photo.id}: ${photo.filename}`);
-      console.log(`  Photo path: ${photo.path}`);
-      console.log(`  Thumbnail path in DB: ${photo.thumbnail_path}`);
-      
-      if (photo.thumbnail_path) {
-        // Expected thumbnail filename
-        const expectedThumbName = `thumb_${photo.filename}`;
-        const expectedThumbPath = path.join(THUMBNAILS_DIR, expectedThumbName);
-        
-        // Check if thumbnail exists
-        try {
-          await fs.access(expectedThumbPath);
-          console.log(`  ✓ Thumbnail exists at: ${expectedThumbName}`);
-          existingThumbnails++;
-          
-          // Check if DB path matches expected path
-          const dbThumbName = path.basename(photo.thumbnail_path);
-          if (dbThumbName !== expectedThumbName) {
-            console.log(`  ⚠ Path mismatch! DB has: ${dbThumbName}, Expected: ${expectedThumbName}`);
-            pathIssues.push({
-              photoId: photo.id,
-              dbPath: photo.thumbnail_path,
-              expectedPath: `thumbnails/${expectedThumbName}`
-            });
-          }
-        } catch {
-          console.log(`  ✗ Thumbnail missing: ${expectedThumbName}`);
-          missingThumbnails++;
-        }
-      } else {
-        console.log(`  ✗ No thumbnail path in database`);
-        missingThumbnails++;
-      }
-      console.log('');
-    }
-    
-    console.log('--- Summary ---');
-    console.log(`Existing thumbnails: ${existingThumbnails}`);
-    console.log(`Missing thumbnails: ${missingThumbnails}`);
-    console.log(`Path issues: ${pathIssues.length}`);
-    
-    if (pathIssues.length > 0) {
-      console.log('\n--- Path Issues ---');
-      console.log('The following photos have incorrect thumbnail paths in the database:');
-      for (const issue of pathIssues) {
-        console.log(`Photo ID ${issue.photoId}:`);
-        console.log(`  Current: ${issue.dbPath}`);
-        console.log(`  Should be: ${issue.expectedPath}`);
-      }
-      
-      console.log('\nTo fix path issues, run:');
-      console.log(`UPDATE photos SET thumbnail_path = 'thumbnails/thumb_' || filename WHERE event_id = ${eventId};`);
-    }
-    
-    // Check for any thumbnails in the directory that match this event
-    const files = await fs.readdir(THUMBNAILS_DIR);
-    const eventThumbnails = files.filter(f => {
-      // Try to match thumbnails for this event
-      for (const photo of photos) {
-        if (f === `thumb_${photo.filename}`) return true;
-      }
-      return false;
-    });
-    
-    console.log(`\n--- Filesystem Check ---`);
-    console.log(`Found ${eventThumbnails.length} thumbnails in directory for this event`);
-    
-  } catch (error) {
-    console.error('Error during diagnosis:', error);
-    process.exit(1);
-  }
-}
-
-// Parse command line arguments
-const eventId = process.argv[2] ? parseInt(process.argv[2]) : null;
-
-// Run the diagnosis
-diagnoseThumbnails(eventId).then(async () => {
-  await db.destroy();
-  console.log('\nDiagnosis complete');
-}).catch(async error => {
-  console.error('Diagnosis failed:', error);
-  await db.destroy();
-  process.exit(1);
-});

backend/scripts/fix-email-queue-schema.js

@@ -1,99 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Script to diagnose and fix email_queue schema issues
- * This helps resolve the "column updated_at does not exist" error
- */
-
-require('dotenv').config();
-const { db } = require('../src/database/db');
-
-async function checkAndFixEmailQueueSchema() {
-  console.log('Checking email_queue table schema...');
-  
-  try {
-    // Get column information
-    const columns = await db('email_queue').columnInfo();
-    console.log('\nCurrent email_queue columns:', Object.keys(columns));
-    
-    // Check for updated_at column
-    if (columns.updated_at) {
-      console.log('\n⚠️  Found unexpected updated_at column in email_queue table!');
-      console.log('This column should not exist and is causing errors.');
-      
-      // Ask for confirmation before removing
-      console.log('\nRemoving updated_at column...');
-      await db.schema.table('email_queue', (table) => {
-        table.dropColumn('updated_at');
-      });
-      console.log('✅ Removed updated_at column from email_queue table');
-    } else {
-      console.log('✅ No updated_at column found (this is correct)');
-    }
-    
-    // Verify required columns exist
-    const requiredColumns = [
-      'id', 'event_id', 'recipient_email', 'email_type', 
-      'email_data', 'status', 'scheduled_at', 'sent_at', 
-      'error_message', 'retry_count', 'created_at'
-    ];
-    
-    const missingColumns = requiredColumns.filter(col => !columns[col]);
-    if (missingColumns.length > 0) {
-      console.log('\n⚠️  Missing required columns:', missingColumns);
-    } else {
-      console.log('✅ All required columns are present');
-    }
-    
-    // Check for any database triggers
-    if (process.env.DATABASE_CLIENT === 'pg') {
-      console.log('\nChecking for PostgreSQL triggers on email_queue...');
-      const triggers = await db.raw(`
-        SELECT trigger_name, event_manipulation, action_statement
-        FROM information_schema.triggers
-        WHERE event_object_table = 'email_queue'
-        AND trigger_schema = current_schema()
-      `);
-      
-      if (triggers.rows && triggers.rows.length > 0) {
-        console.log('⚠️  Found triggers on email_queue table:');
-        triggers.rows.forEach(trigger => {
-          console.log(`  - ${trigger.trigger_name} (${trigger.event_manipulation})`);
-        });
-      } else {
-        console.log('✅ No triggers found on email_queue table');
-      }
-    }
-    
-    // Test update query
-    console.log('\nTesting update query...');
-    const testEmail = await db('email_queue')
-      .where('status', 'pending')
-      .first();
-    
-    if (testEmail) {
-      try {
-        await db('email_queue')
-          .where('id', testEmail.id)
-          .update({
-            retry_count: testEmail.retry_count
-          });
-        console.log('✅ Update query works correctly');
-      } catch (error) {
-        console.log('❌ Update query failed:', error.message);
-      }
-    } else {
-      console.log('ℹ️  No pending emails to test with');
-    }
-    
-    console.log('\nSchema check complete!');
-    
-  } catch (error) {
-    console.error('Error checking schema:', error);
-  } finally {
-    await db.destroy();
-  }
-}
-
-// Run the check
-checkAndFixEmailQueueSchema();

backend/scripts/fix-final-german-templates.js

@@ -1,88 +0,0 @@
-const { db } = require('../src/database/db');
-
-async function fixFinalGermanTemplates() {
-  try {
-    console.log('Fixing remaining English words in German templates...\n');
-    
-    // Get all templates
-    const templates = await db('email_templates').select('*');
-    
-    for (const template of templates) {
-      let updated = false;
-      let updates = {};
-      
-      // Fix subject_de
-      if (template.subject_de) {
-        updates.subject_de = template.subject_de;
-      }
-      
-      // Fix body_html_de
-      if (template.body_html_de) {
-        let html = template.body_html_de;
-        
-        // Replace English words with German
-        html = html.replace(/Gallery-Details:/g, 'Galerie-Details:');
-        html = html.replace(/Galerie-Details:/g, 'Galerie-Details:');
-        html = html.replace(/Details:/g, 'Details:');
-        html = html.replace(/Link:/g, 'Link:');
-        html = html.replace(/Gallery-Link:/g, 'Galerie-Link:');
-        html = html.replace(/Galerie-Link:/g, 'Galerie-Link:');
-        html = html.replace(/Archive-Details:/g, 'Archiv-Details:');
-        html = html.replace(/Archiv-Details:/g, 'Archiv-Details:');
-        
-        if (html !== template.body_html_de) {
-          updates.body_html_de = html;
-          updated = true;
-        }
-      }
-      
-      // Fix body_text_de
-      if (template.body_text_de) {
-        let text = template.body_text_de;
-        
-        text = text.replace(/Gallery-Details:/g, 'Galerie-Details:');
-        text = text.replace(/Galerie-Details:/g, 'Galerie-Details:');
-        text = text.replace(/Details:/g, 'Details:');
-        text = text.replace(/Link:/g, 'Link:');
-        text = text.replace(/Gallery-Link:/g, 'Galerie-Link:');
-        text = text.replace(/Galerie-Link:/g, 'Galerie-Link:');
-        text = text.replace(/Archive-Details:/g, 'Archiv-Details:');
-        text = text.replace(/Archiv-Details:/g, 'Archiv-Details:');
-        
-        if (text !== template.body_text_de) {
-          updates.body_text_de = text;
-          updated = true;
-        }
-      }
-      
-      // Also update the non-language-specific fields to match German
-      if (template.body_html_de) {
-        updates.body_html = template.body_html_de;
-      }
-      if (template.body_text_de) {
-        updates.body_text = template.body_text_de;
-      }
-      if (template.subject_de) {
-        updates.subject = template.subject_de;
-      }
-      
-      if (updated || Object.keys(updates).length > 0) {
-        await db('email_templates')
-          .where('template_key', template.template_key)
-          .update(updates);
-        console.log(`✅ Updated ${template.template_key}`);
-      } else {
-        console.log(`⏭️  No changes needed for ${template.template_key}`);
-      }
-    }
-    
-    console.log('\nDone!');
-    await db.destroy();
-  } catch (error) {
-    console.error('Error:', error);
-    await db.destroy();
-    process.exit(1);
-  }
-}
-
-fixFinalGermanTemplates();

backend/scripts/fix-production-issues.js

@@ -1,145 +0,0 @@
-require('dotenv').config();
-const { db } = require('../src/database/db');
-
-async function fixProductionIssues() {
-  console.log('Fixing production database issues...\n');
-  
-  try {
-    // 1. Check and fix email_templates structure
-    console.log('1. Checking email_templates structure:');
-    const emailColumns = await db('email_templates').columnInfo();
-    console.log('Current columns:', Object.keys(emailColumns));
-    
-    // Check if we need to add basic columns back
-    const hasSubject = 'subject' in emailColumns;
-    const hasSubjectEn = 'subject_en' in emailColumns;
-    
-    if (hasSubjectEn && !hasSubject) {
-      console.log('Adding basic columns back to email_templates...');
-      await db.schema.alterTable('email_templates', (table) => {
-        table.string('subject');
-        table.text('body_html');
-        table.text('body_text');
-      });
-      
-      // Copy values from _en columns
-      await db('email_templates').update({
-        subject: db.raw('subject_en'),
-        body_html: db.raw('body_html_en'),
-        body_text: db.raw('body_text_en')
-      });
-      console.log('Basic columns added successfully');
-    }
-    
-    // 2. Ensure default templates exist
-    console.log('\n2. Checking email templates:');
-    const templateCount = await db('email_templates').count('* as count');
-    console.log('Template count:', templateCount[0].count);
-    
-    if (templateCount[0].count === 0) {
-      console.log('No templates found, inserting defaults...');
-      const defaultTemplates = [
-        {
-          template_key: 'gallery_created',
-          subject: 'Your Photo Gallery is Ready!',
-          body_html: '<h2>Gallery Created Successfully</h2>...',
-          body_text: 'Gallery Created Successfully...',
-          variables: JSON.stringify(['host_name', 'event_name', 'event_date', 'gallery_link', 'gallery_password', 'expiry_date'])
-        },
-        {
-          template_key: 'expiration_warning',
-          subject: 'Your Photo Gallery Expires Soon',
-          body_html: '<h2>Gallery Expiring Soon</h2>...',
-          body_text: 'Gallery Expiring Soon...',
-          variables: JSON.stringify(['host_name', 'event_name', 'days_remaining', 'gallery_link'])
-        },
-        {
-          template_key: 'gallery_expired',
-          subject: 'Your Photo Gallery Has Expired',
-          body_html: '<h2>Gallery Expired</h2>...',
-          body_text: 'Gallery Expired...',
-          variables: JSON.stringify(['host_name', 'event_name'])
-        },
-        {
-          template_key: 'archive_complete',
-          subject: 'Gallery Archive Complete',
-          body_html: '<h2>Archive Complete</h2>...',
-          body_text: 'Archive Complete...',
-          variables: JSON.stringify(['host_name', 'event_name', 'archive_size'])
-        }
-      ];
-      
-      for (const template of defaultTemplates) {
-        // Add language columns if they exist
-        if (hasSubjectEn) {
-          template.subject_en = template.subject;
-          template.body_html_en = template.body_html;
-          template.body_text_en = template.body_text;
-          template.subject_de = template.subject;
-          template.body_html_de = template.body_html;
-          template.body_text_de = template.body_text;
-        }
-        
-        await db('email_templates').insert(template);
-      }
-      console.log('Default templates inserted');
-    }
-    
-    // 3. Check activity_logs structure
-    console.log('\n3. Checking activity_logs structure:');
-    const activityColumns = await db('activity_logs').columnInfo();
-    console.log('Columns:', Object.keys(activityColumns));
-    
-    // Check if read_at exists
-    if (!('read_at' in activityColumns)) {
-      console.log('Adding read_at column to activity_logs...');
-      await db.schema.alterTable('activity_logs', (table) => {
-        table.datetime('read_at').nullable();
-      });
-      console.log('read_at column added');
-    }
-    
-    // 4. Check and add CMS pages
-    console.log('\n4. Checking CMS pages:');
-    const cmsColumns = await db('cms_pages').columnInfo();
-    console.log('CMS columns:', Object.keys(cmsColumns));
-    
-    const impressum = await db('cms_pages').where('slug', 'impressum').first();
-    const datenschutz = await db('cms_pages').where('slug', 'datenschutz').first();
-    
-    if (!impressum) {
-      console.log('Adding Impressum page...');
-      await db('cms_pages').insert({
-        slug: 'impressum',
-        title_en: 'Legal Notice',
-        title_de: 'Impressum',
-        content_en: '<h1>Legal Notice</h1><p>Your legal information here...</p>',
-        content_de: '<h1>Impressum</h1><p>Ihre rechtlichen Informationen hier...</p>',
-        updated_at: new Date()
-      });
-    }
-    
-    if (!datenschutz) {
-      console.log('Adding Datenschutz page...');
-      await db('cms_pages').insert({
-        slug: 'datenschutz',
-        title_en: 'Privacy Policy',
-        title_de: 'Datenschutzerklärung',
-        content_en: '<h1>Privacy Policy</h1><p>Your privacy policy here...</p>',
-        content_de: '<h1>Datenschutzerklärung</h1><p>Ihre Datenschutzerklärung hier...</p>',
-        updated_at: new Date()
-      });
-    }
-    
-    console.log('\n✅ All fixes applied successfully!');
-    
-  } catch (error) {
-    console.error('Error fixing issues:', error);
-    console.error('Stack:', error.stack);
-  } finally {
-    await db.destroy();
-    process.exit(0);
-  }
-}
-
-fixProductionIssues();

backend/scripts/fix-stuck-emails.js

@@ -1,126 +0,0 @@
-const { db } = require('../src/database/db');
-const winston = require('winston');
-
-// Create a simple console logger
-const logger = winston.createLogger({
-  format: winston.format.simple(),
-  transports: [new winston.transports.Console()]
-});
-
-async function fixStuckEmails() {
-  try {
-    logger.info('=== Fix Stuck Emails Script ===\n');
-    
-    // 1. Find stuck emails
-    logger.info('1. Finding stuck emails (pending with retry_count >= 3)...');
-    const stuckEmails = await db('email_queue')
-      .where('status', 'pending')
-      .where('retry_count', '>=', 3)
-      .select('*');
-    
-    if (stuckEmails.length === 0) {
-      logger.info('   ✅ No stuck emails found!');
-      logger.info('\n=== Script complete ===');
-      await db.destroy();
-      process.exit(0);
-    }
-    
-    logger.info(`   Found ${stuckEmails.length} stuck email(s)\n`);
-    
-    // 2. Show details
-    logger.info('2. Stuck email details:');
-    stuckEmails.forEach((email, index) => {
-      logger.info(`\n   Email ${index + 1}:`);
-      logger.info(`     ID: ${email.id}`);
-      logger.info(`     Type: ${email.email_type}`);
-      logger.info(`     Recipient: ${email.recipient_email}`);
-      logger.info(`     Retry Count: ${email.retry_count}`);
-      logger.info(`     Last Error: ${email.error_message || 'None'}`);
-    });
-    
-    // 3. Ask for action
-    logger.info('\n\n3. Choose an action:');
-    logger.info('   1. Reset retry count to 0 (emails will be retried)');
-    logger.info('   2. Mark as failed (emails will not be retried)');
-    logger.info('   3. Delete these emails');
-    logger.info('   4. Cancel (do nothing)');
-    
-    // Get command line argument
-    const action = process.argv[2];
-    
-    if (!action || !['reset', 'fail', 'delete'].includes(action)) {
-      logger.info('\n❗ No valid action specified');
-      logger.info('\nUsage:');
-      logger.info('  node fix-stuck-emails.js reset   - Reset retry count to 0');
-      logger.info('  node fix-stuck-emails.js fail    - Mark as failed');
-      logger.info('  node fix-stuck-emails.js delete  - Delete stuck emails');
-      await db.destroy();
-      process.exit(1);
-    }
-    
-    // 4. Execute action
-    logger.info(`\n4. Executing action: ${action.toUpperCase()}`);
-    
-    const emailIds = stuckEmails.map(e => e.id);
-    
-    switch (action) {
-      case 'reset':
-        await db('email_queue')
-          .whereIn('id', emailIds)
-          .update({
-            retry_count: 0,
-            error_message: null
-          });
-        logger.info(`   ✅ Reset retry count for ${emailIds.length} email(s)`);
-        logger.info('   These emails will be processed on the next run');
-        break;
-        
-      case 'fail':
-        await db('email_queue')
-          .whereIn('id', emailIds)
-          .update({
-            status: 'failed'
-          });
-        logger.info(`   ✅ Marked ${emailIds.length} email(s) as failed`);
-        logger.info('   These emails will not be retried');
-        break;
-        
-      case 'delete':
-        await db('email_queue')
-          .whereIn('id', emailIds)
-          .delete();
-        logger.info(`   ✅ Deleted ${emailIds.length} email(s)`);
-        break;
-    }
-    
-    // 5. Show updated counts
-    logger.info('\n5. Updated email queue status:');
-    const [pendingCount] = await db('email_queue')
-      .where('status', 'pending')
-      .count('* as count');
-    const [processableCount] = await db('email_queue')
-      .where('status', 'pending')
-      .where('retry_count', '<', 3)
-      .count('* as count');
-    
-    logger.info(`   Total pending: ${pendingCount.count}`);
-    logger.info(`   Processable (retry < 3): ${processableCount.count}`);
-    
-    if (pendingCount.count !== processableCount.count) {
-      logger.info(`   ⚠️  Still have ${pendingCount.count - processableCount.count} stuck email(s)`);
-    } else {
-      logger.info('   ✅ No stuck emails remaining');
-    }
-    
-    logger.info('\n=== Script complete ===');
-    
-  } catch (error) {
-    logger.error('Error:', error);
-  } finally {
-    await db.destroy();
-    process.exit(0);
-  }
-}
-
-// Run the fix
-fixStuckEmails();

backend/scripts/fix-temp-photos.js

@@ -1,171 +0,0 @@
-require('dotenv').config({ path: '../.env' });
-const path = require('path');
-const fs = require('fs').promises;
-const { db } = require('../src/database/db');
-const { generatePhotoFilename } = require('../src/utils/filenameSanitizer');
-
-async function fixTempPhotos() {
-  console.log('Starting to fix temporary photo files...\n');
-  
-  try {
-    // Find all photos with temp_ filenames
-    const tempPhotos = await db('photos')
-      .where('filename', 'like', 'temp_%')
-      .orderBy('event_id', 'asc')
-      .orderBy('category_id', 'asc')
-      .orderBy('id', 'asc');
-    
-    console.log(`Found ${tempPhotos.length} photos with temporary filenames\n`);
-    
-    if (tempPhotos.length === 0) {
-      console.log('No temporary photos found. Exiting.');
-      return;
-    }
-    
-    // Group photos by event and category
-    const grouped = {};
-    for (const photo of tempPhotos) {
-      const key = `${photo.event_id}_${photo.category_id || 'null'}`;
-      if (!grouped[key]) {
-        grouped[key] = [];
-      }
-      grouped[key].push(photo);
-    }
-    
-    console.log(`Processing ${Object.keys(grouped).length} event/category groups...\n`);
-    
-    // Process each group
-    for (const [key, photos] of Object.entries(grouped)) {
-      const [eventId, categoryIdStr] = key.split('_');
-      const categoryId = categoryIdStr === 'null' ? null : parseInt(categoryIdStr);
-      
-      console.log(`\nProcessing Event ID: ${eventId}, Category ID: ${categoryId || 'uncategorized'}`);
-      console.log(`Photos in group: ${photos.length}`);
-      
-      // Get event details
-      const event = await db('events').where({ id: eventId }).first();
-      if (!event) {
-        console.error(`Event ${eventId} not found! Skipping...`);
-        continue;
-      }
-      
-      // Get category details if applicable
-      let category = null;
-      let startCounter = 1;
-      
-      if (categoryId) {
-        category = await db('photo_categories').where({ id: categoryId }).first();
-        if (!category) {
-          console.error(`Category ${categoryId} not found! Treating as uncategorized...`);
-        } else {
-          // Get the highest counter for this category
-          const maxPhoto = await db('photos')
-            .where({ event_id: eventId, category_id: categoryId })
-            .whereNot('filename', 'like', 'temp_%')
-            .orderBy('id', 'desc')
-            .first();
-          
-          if (maxPhoto && maxPhoto.filename) {
-            // Extract counter from filename
-            const match = maxPhoto.filename.match(/_(\d+)\.[^.]+$/);
-            if (match) {
-              startCounter = parseInt(match[1]) + 1;
-            }
-          }
-        }
-      } else {
-        // For uncategorized, get the highest counter
-        const maxPhoto = await db('photos')
-          .where({ event_id: eventId })
-          .whereNull('category_id')
-          .whereNot('filename', 'like', 'temp_%')
-          .orderBy('id', 'desc')
-          .first();
-        
-        if (maxPhoto && maxPhoto.filename) {
-          const match = maxPhoto.filename.match(/_(\d+)\.[^.]+$/);
-          if (match) {
-            startCounter = parseInt(match[1]) + 1;
-          }
-        }
-      }
-      
-      console.log(`Starting counter: ${startCounter}`);
-      
-      // Process each photo in the group
-      let successCount = 0;
-      let errorCount = 0;
-      
-      for (let i = 0; i < photos.length; i++) {
-        const photo = photos[i];
-        const counter = startCounter + i;
-        
-        try {
-          // Generate new filename
-          const extension = path.extname(photo.filename);
-          const newFilename = generatePhotoFilename(
-            event.event_name,
-            category ? category.name : 'uncategorized',
-            counter,
-            extension
-          );
-          
-          // Build full paths
-          const storagePath = process.env.STORAGE_PATH || path.join(__dirname, '../../storage');
-          const oldPath = path.join(storagePath, 'events/active', photo.path);
-          const newPath = path.join(path.dirname(oldPath), newFilename);
-          
-          // Check if old file exists
-          try {
-            await fs.access(oldPath);
-          } catch (e) {
-            console.error(`File not found: ${oldPath}`);
-            errorCount++;
-            continue;
-          }
-          
-          // Rename the file
-          await fs.rename(oldPath, newPath);
-          
-          // Update database
-          const newRelativePath = path.relative(path.join(storagePath, 'events/active'), newPath);
-          await db('photos')
-            .where({ id: photo.id })
-            .update({
-              filename: newFilename,
-              path: newRelativePath
-            });
-          
-          console.log(`✓ Renamed: ${photo.filename} → ${newFilename}`);
-          successCount++;
-          
-        } catch (error) {
-          console.error(`✗ Failed to process photo ${photo.id}: ${error.message}`);
-          errorCount++;
-        }
-      }
-      
-      // Update category counter if needed
-      if (category && successCount > 0) {
-        const newCounter = startCounter + photos.length - 1;
-        await db('photo_categories')
-          .where({ id: categoryId })
-          .update({ photo_counter: newCounter });
-        console.log(`Updated category counter to ${newCounter}`);
-      }
-      
-      console.log(`\nGroup summary: ${successCount} successful, ${errorCount} errors`);
-    }
-    
-    console.log('\n=== COMPLETE ===');
-    console.log('All temporary photos have been processed.');
-    
-  } catch (error) {
-    console.error('Fatal error:', error);
-  } finally {
-    await db.destroy();
-  }
-}
-
-// Run the script
-fixTempPhotos().catch(console.error);

backend/scripts/regenerate-square-thumbnails.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+
+/**
+ * Script to regenerate all thumbnails with new square dimensions
+ * This fixes the blurry thumbnail issue by creating proper 300x300 square thumbnails
+ */
+
+const path = require('path');
+const fs = require('fs').promises;
+const { db } = require('../src/database/db');
+const { generateThumbnail } = require('../src/services/imageProcessor');
+const logger = require('../src/utils/logger');
+
+const getStoragePath = () => process.env.STORAGE_PATH || path.join(__dirname, '../../storage');
+
+async function regenerateAllThumbnails() {
+  try {
+    console.log('Starting thumbnail regeneration with square dimensions...');
+    
+    // First, ensure the new thumbnail settings are in the database
+    const settings = [
+      { key: 'thumbnail_width', value: '300' },
+      { key: 'thumbnail_height', value: '300' },
+      { key: 'thumbnail_fit', value: 'cover' },
+      { key: 'thumbnail_quality', value: '85' },
+      { key: 'thumbnail_format', value: 'jpeg' }
+    ];
+    
+    for (const setting of settings) {
+      const exists = await db('app_settings').where('key', setting.key).first();
+      if (!exists) {
+        await db('app_settings').insert({
+          ...setting,
+          description: `Thumbnail ${setting.key.replace('thumbnail_', '')}`,
+          created_at: db.fn.now(),
+          updated_at: db.fn.now()
+        });
+        console.log(`Added setting: ${setting.key} = ${setting.value}`);
+      }
+    }
+    
+    // Get all photos
+    const photos = await db('photos')
+      .select('id', 'event_id', 'path', 'filename')
+      .orderBy('id');
+    
+    console.log(`Found ${photos.length} photos to process`);
+    
+    let successCount = 0;
+    let errorCount = 0;
+    let skippedCount = 0;
+    
+    for (let i = 0; i < photos.length; i++) {
+      const photo = photos[i];
+      const progress = Math.round((i + 1) / photos.length * 100);
+      
+      try {
+        const storagePath = getStoragePath();
+        const originalPath = path.join(storagePath, 'events/active', photo.path);
+        
+        // Check if original file exists
+        try {
+          await fs.access(originalPath);
+        } catch (err) {
+          console.log(`[${progress}%] Skipping photo ${photo.id} - original file not found`);
+          skippedCount++;
+          continue;
+        }
+        
+        // Regenerate thumbnail with new square dimensions
+        const thumbnailPath = await generateThumbnail(originalPath, { regenerate: true });
+        
+        if (thumbnailPath) {
+          // Update database with new thumbnail path
+          await db('photos')
+            .where({ id: photo.id })
+            .update({ 
+              thumbnail_path: thumbnailPath,
+              updated_at: db.fn.now()
+            });
+          
+          successCount++;
+          console.log(`[${progress}%] ✓ Regenerated thumbnail for ${photo.filename}`);
+        } else {
+          errorCount++;
+          console.error(`[${progress}%] ✗ Failed to generate thumbnail for ${photo.filename}`);
+        }
+      } catch (error) {
+        errorCount++;
+        console.error(`[${progress}%] ✗ Error processing photo ${photo.id}:`, error.message);
+      }
+    }
+    
+    console.log('\n=== Regeneration Complete ===');
+    console.log(`✓ Success: ${successCount} thumbnails`);
+    console.log(`✗ Errors: ${errorCount} thumbnails`);
+    console.log(`⊘ Skipped: ${skippedCount} thumbnails (original files not found)`);
+    console.log(`Total processed: ${photos.length} photos`);
+    
+    process.exit(0);
+  } catch (error) {
+    console.error('Fatal error during thumbnail regeneration:', error);
+    process.exit(1);
+  }
+}
+
+// Run the script
+regenerateAllThumbnails();

backend/scripts/run-email-processor.js

@@ -1,111 +0,0 @@
-#!/usr/bin/env node
-
-const { db } = require('../src/database/db');
-const { 
-  initializeTransporter, 
-  processEmailQueue, 
-  testEmailConnection 
-} = require('../src/services/emailProcessor');
-const winston = require('winston');
-
-// Create a simple console logger
-const logger = winston.createLogger({
-  format: winston.format.simple(),
-  transports: [new winston.transports.Console()]
-});
-
-async function runEmailProcessor(runOnce = false) {
-  try {
-    logger.info('=== Starting Email Processor ===\n');
-    
-    // Initialize transporter
-    logger.info('Initializing email transporter...');
-    await initializeTransporter();
-    
-    // Test connection
-    logger.info('Testing email connection...');
-    const connectionOk = await testEmailConnection();
-    
-    if (!connectionOk) {
-      logger.error('Email connection test failed! Check your SMTP configuration.');
-      logger.info('\nRequired environment variables:');
-      logger.info('- SMTP_HOST');
-      logger.info('- SMTP_PORT');
-      logger.info('- SMTP_USER');
-      logger.info('- SMTP_PASS');
-      logger.info('- SMTP_FROM');
-      process.exit(1);
-    }
-    
-    logger.info('Email connection test successful!\n');
-    
-    if (runOnce) {
-      // Process queue once
-      logger.info('Processing email queue once...');
-      await processEmailQueue();
-      logger.info('Email processing complete');
-      
-      // Show final status
-      const pendingCount = await db('email_queue')
-        .where('status', 'pending')
-        .where('retry_count', '<', 3)
-        .count('* as count')
-        .first();
-      
-      logger.info(`\nEmails still pending: ${pendingCount.count}`);
-      
-      await db.destroy();
-      process.exit(0);
-    } else {
-      // Run continuously
-      logger.info('Starting continuous email processor...');
-      logger.info('Processing emails every 60 seconds. Press Ctrl+C to stop.\n');
-      
-      // Process immediately
-      await processEmailQueue();
-      
-      // Then every minute
-      setInterval(async () => {
-        try {
-          await processEmailQueue();
-        } catch (error) {
-          logger.error('Error processing email queue:', error);
-        }
-      }, 60000);
-    }
-    
-  } catch (error) {
-    logger.error('Fatal error:', error);
-    await db.destroy();
-    process.exit(1);
-  }
-}
-
-// Handle graceful shutdown
-process.on('SIGINT', async () => {
-  logger.info('\n\nShutting down email processor...');
-  await db.destroy();
-  process.exit(0);
-});
-
-// Check command line arguments
-const args = process.argv.slice(2);
-const runOnce = args.includes('--once') || args.includes('-o');
-
-if (args.includes('--help') || args.includes('-h')) {
-  console.log(`
-Email Processor Runner
-
-Usage: node run-email-processor.js [options]
-
-Options:
-  --once, -o     Process the email queue once and exit
-  --help, -h     Show this help message
-
-By default, the processor runs continuously, checking for emails every 60 seconds.
-  `);
-  process.exit(0);
-}
-
-// Run the processor
-runEmailProcessor(runOnce);

backend/scripts/run-migrations.js

@@ -1,40 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Run database migrations using existing db connection
- */
-
-const { db } = require('../src/database/db');
-
-async function runMigrations() {
-  console.log('Running database migrations...\n');
-  
-  try {
-    // Run all pending migrations
-    const result = await db.migrate.latest({
-      directory: './migrations'
-    });
-    
-    if (result[1].length === 0) {
-      console.log('✓ Database is already up to date');
-    } else {
-      console.log(`✓ Ran ${result[1].length} migrations:`);
-      result[1].forEach(migration => {
-        console.log(`  - ${migration}`);
-      });
-    }
-    
-    // Show current migration status
-    const list = await db.migrate.list();
-    console.log(`\nCurrent status: ${list[0].length} completed migrations`);
-    
-    await db.destroy();
-    process.exit(0);
-  } catch (error) {
-    console.error('Migration error:', error);
-    await db.destroy();
-    process.exit(1);
-  }
-}
-
-runMigrations();