chore: bump version to 1.0.28

Fixed boolean value handling differences between databases:
- SQLite stores booleans as 0/1, PostgreSQL as true/false
- Add formatBoolean() calls to critical queries that were failing

Files fixed:
- adminEvents.js: Fixed status filters and archive queries
- adminDashboard.js: Fixed active/archived event counts
- expirationChecker.js: Fixed expiration checking queries
- dbCompat.js: Updated to avoid circular dependency

Added migration 024 to:
- Enable foreign keys for SQLite (PRAGMA foreign_keys = ON)
- Document boolean compatibility requirements

This fixes queries returning 0 results in SQLite when checking
boolean columns like is_active, is_archived. Critical for
proper event management and expiration handling.

Note: 23 more boolean comparisons remain to be fixed in other files.

.claudedocs/scans/security-20250713.md

@@ -0,0 +1,286 @@
+# 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.full

@@ -1,280 +0,0 @@
-kind: pipeline
-type: docker
-name: default
-
-trigger:
-  branch:
-    - main
-    - develop
-    - feature/*
-  event:
-    - push
-    - pull_request
-    - tag
-
-volumes:
-  - name: docker
-    host:
-      path: /var/run/docker.sock
-
-steps:
-  # Frontend Tests
-  - name: frontend-test
-    image: node:18-alpine
-    commands:
-      - cd frontend
-      - npm ci --legacy-peer-deps
-      - npm run lint
-      - npm run build
-    when:
-      event:
-        - push
-        - pull_request
-
-  # Backend Tests
-  - name: backend-test
-    image: node:18-alpine
-    commands:
-      - cd backend
-      - npm ci
-      - npm run lint
-      - npm test
-    environment:
-      NODE_ENV: test
-      JWT_SECRET: test-secret
-    when:
-      event:
-        - push
-        - pull_request
-
-  # Build Frontend Docker Image
-  - name: build-frontend
-    image: plugins/docker
-    settings:
-      repo: registry.local.nothaft.cloud/wedding-photo-sharing-frontend
-      tags:
-        - latest
-        - ${DRONE_COMMIT_SHA:0:8}
-        - ${DRONE_TAG}
-      dockerfile: frontend/Dockerfile
-      context: frontend
-      registry: registry.local.nothaft.cloud
-    when:
-      branch:
-        - main
-      event:
-        - push
-        - tag
-
-  # Build Backend Docker Image
-  - name: build-backend
-    image: plugins/docker
-    settings:
-      repo: registry.local.nothaft.cloud/wedding-photo-sharing-backend
-      tags:
-        - latest
-        - ${DRONE_COMMIT_SHA:0:8}
-        - ${DRONE_TAG}
-      dockerfile: backend/Dockerfile
-      context: backend
-      registry: registry.local.nothaft.cloud
-    when:
-      branch:
-        - main
-      event:
-        - push
-        - tag
-
-  # Security Scan
-  - name: security-scan
-    image: aquasec/trivy:latest
-    commands:
-      - trivy image --exit-code 0 --no-progress registry.local.nothaft.cloud/wedding-photo-sharing-frontend:${DRONE_COMMIT_SHA:0:8}
-      - trivy image --exit-code 0 --no-progress registry.local.nothaft.cloud/wedding-photo-sharing-backend:${DRONE_COMMIT_SHA:0:8}
-    environment:
-      DOCKER_HOST: tcp://docker:2375
-    volumes:
-      - name: docker
-        path: /var/run/docker.sock
-    when:
-      branch:
-        - main
-      event:
-        - push
-
-  # Deploy to Staging
-  - name: deploy-staging
-    image: alpine:latest
-    environment:
-      SWARM_HOST:
-        from_secret: staging_swarm_host
-      SWARM_USER:
-        from_secret: staging_swarm_user
-      SWARM_KEY:
-        from_secret: staging_swarm_key
-      REGISTRY_URL:
-        from_secret: docker_registry
-      VERSION: ${DRONE_COMMIT_SHA:0:8}
-    commands:
-      - apk add --no-cache openssh-client
-      - mkdir -p ~/.ssh
-      - echo "$SWARM_KEY" > ~/.ssh/id_rsa
-      - chmod 600 ~/.ssh/id_rsa
-      - ssh-keyscan -H $SWARM_HOST >> ~/.ssh/known_hosts
-      - |
-        ssh $SWARM_USER@$SWARM_HOST << EOF
-          cd /opt/wedding-photo-sharing
-          export REGISTRY_URL=registry.local.nothaft.cloud
-          export VERSION=$VERSION
-          docker stack deploy -c deploy/docker-stack.yml wedding-photo-sharing
-        EOF
-    when:
-      branch:
-        - develop
-      event:
-        - push
-
-  # Deploy to Production
-  - name: deploy-production
-    image: alpine:latest
-    environment:
-      SWARM_HOST:
-        from_secret: prod_swarm_host
-      SWARM_USER:
-        from_secret: prod_swarm_user
-      SWARM_KEY:
-        from_secret: prod_swarm_key
-      REGISTRY_URL:
-        from_secret: docker_registry
-      VERSION: ${DRONE_TAG:-latest}
-    commands:
-      - apk add --no-cache openssh-client
-      - mkdir -p ~/.ssh
-      - echo "$SWARM_KEY" > ~/.ssh/id_rsa
-      - chmod 600 ~/.ssh/id_rsa
-      - ssh-keyscan -H $SWARM_HOST >> ~/.ssh/known_hosts
-      - |
-        ssh $SWARM_USER@$SWARM_HOST << EOF
-          cd /opt/wedding-photo-sharing
-          export REGISTRY_URL=registry.local.nothaft.cloud
-          export VERSION=$VERSION
-          
-          # Backup database before deployment
-          docker exec \$(docker ps -q -f name=wedding-photo-sharing_db) pg_dump -U postgres wedding_photo_sharing > /backup/db-backup-\$(date +%Y%m%d-%H%M%S).sql
-          
-          # Deploy stack
-          docker stack deploy -c deploy/docker-stack.yml wedding-photo-sharing --with-registry-auth
-          
-          # Wait for services to be ready
-          sleep 30
-          
-          # Run migrations if needed
-          docker exec \$(docker ps -q -f name=wedding-photo-sharing_backend) npm run migrate
-        EOF
-    when:
-      event:
-        - tag
-
-  # Health Check
-  - name: health-check
-    image: alpine:latest
-    commands:
-      - apk add --no-cache curl
-      - sleep 30
-      - curl -f https://${FRONTEND_HOST}/health || exit 1
-      - curl -f https://${BACKEND_HOST}/api/health || exit 1
-    when:
-      branch:
-        - main
-      event:
-        - push
-        - tag
-
-  # Notification - Success
-  - name: notify-success
-    image: plugins/slack
-    settings:
-      webhook:
-        from_secret: slack_webhook
-      channel: deployments
-      template: |
-        ✅ *Build {{build.number}} succeeded* for {{repo.name}}
-        
-        Branch: {{build.branch}}
-        Commit: {{build.commit}}
-        Author: {{build.author}}
-        
-        {{#if build.tag}}
-        🏷️ Tag: {{build.tag}}
-        🚀 Deployed to *PRODUCTION*
-        {{else}}
-        📦 Deployed to *{{build.branch}}*
-        {{/if}}
-        
-        🔗 {{build.link}}
-    when:
-      status:
-        - success
-
-  # Notification - Failure
-  - name: notify-failure
-    image: plugins/slack
-    settings:
-      webhook:
-        from_secret: slack_webhook
-      channel: deployments
-      template: |
-        ❌ *Build {{build.number}} failed* for {{repo.name}}
-        
-        Branch: {{build.branch}}
-        Commit: {{build.commit}}
-        Author: {{build.author}}
-        
-        🔗 {{build.link}}
-    when:
-      status:
-        - failure
-
----
-kind: pipeline
-type: docker
-name: rollback
-
-trigger:
-  event:
-    - rollback
-
-steps:
-  - name: rollback-production
-    image: alpine:latest
-    environment:
-      SWARM_HOST:
-        from_secret: prod_swarm_host
-      SWARM_USER:
-        from_secret: prod_swarm_user
-      SWARM_KEY:
-        from_secret: prod_swarm_key
-      REGISTRY_URL:
-        from_secret: docker_registry
-    commands:
-      - apk add --no-cache openssh-client
-      - mkdir -p ~/.ssh
-      - echo "$SWARM_KEY" > ~/.ssh/id_rsa
-      - chmod 600 ~/.ssh/id_rsa
-      - ssh-keyscan -H $SWARM_HOST >> ~/.ssh/known_hosts
-      - |
-        ssh $SWARM_USER@$SWARM_HOST << EOF
-          cd /opt/wedding-photo-sharing
-          export REGISTRY_URL=registry.local.nothaft.cloud
-          export VERSION=${DRONE_ROLLBACK_TO}
-          
-          # Deploy previous version
-          docker stack deploy -c deploy/docker-stack.yml wedding-photo-sharing --with-registry-auth
-        EOF
-
----
-kind: secret
-name: slack_webhook
-get:
-  path: drone/slack
-  name: webhook

.env.example

@@ -1,26 +1,34 @@
-# JWT Secret for authentication
-# IMPORTANT: Generate a secure random secret with: openssl rand -hex 32
-# NEVER use the default value or commit the actual secret to version control
-JWT_SECRET=CHANGE_ME_TO_A_64_CHARACTER_SECURE_RANDOM_STRING_GENERATED_BY_OPENSSL
+# Environment Configuration Template
+# Copy this file to .env and adjust values for your environment
 
-# URLs
-ADMIN_URL=https://admin.photos.yourdomain.com
-FRONTEND_URL=https://photos.yourdomain.com
+# Development: Use docker-compose.dev.yml
+# Production: Use docker-compose.prod.yml with .env.production.example
 
-# Database (for PostgreSQL in production)
-DB_USER=photoapp
-DB_PASSWORD=secure-password-here
-DB_NAME=photo_sharing
+# JWT Secret (CRITICAL for production)
+# Generate with: openssl rand -base64 32
+JWT_SECRET=dev-secret-change-in-production
+
+# Application URLs
+ADMIN_URL=http://localhost:3005
+FRONTEND_URL=http://localhost:3005
+
+# 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
 
 # Email Configuration
-SMTP_HOST=smtp.gmail.com
-SMTP_PORT=587
+# Development: Uses Mailhog (included in docker-compose.dev.yml)
+# Production: Configure real SMTP server
+SMTP_HOST=mailhog
+SMTP_PORT=1025
 SMTP_SECURE=false
-SMTP_USER=your-email@gmail.com
-SMTP_PASS=your-app-password
-EMAIL_FROM=noreply@yourdomain.com
+SMTP_USER=
+SMTP_PASS=
+EMAIL_FROM=noreply@localhost
 
-# Umami Analytics
-UMAMI_URL=https://analytics.yourdomain.com
-UMAMI_WEBSITE_ID=your-website-id
-UMAMI_HASH_SALT=random-salt-here
+# Optional: Umami Analytics
+UMAMI_URL=
+UMAMI_WEBSITE_ID=
+UMAMI_HASH_SALT=

.env.production.example

@@ -1,60 +1,44 @@
-# Application URLs
-FRONTEND_HOST=photos.yourdomain.com
-BACKEND_HOST=api.photos.yourdomain.com
-ADMIN_URL=https://admin.photos.yourdomain.com
-FRONTEND_URL=https://photos.yourdomain.com
+# PicPeak Production Configuration
+# Copy this file to .env and update with your values
 
-# Database Configuration
-DB_NAME=photo_sharing
-DB_USER=photoapp
-DB_PASSWORD=your-secure-password-here
+# Required: Security
+JWT_SECRET=CHANGE_THIS_TO_RANDOM_32_CHAR_STRING
 
-# JWT Configuration
-JWT_SECRET=your-jwt-secret-here
+# Required: URLs (update with your domain)
+FRONTEND_URL=https://your-domain.com
+BACKEND_URL=https://your-domain.com
+ADMIN_URL=https://your-domain.com
 
-# Email Configuration
+# Required: Email Settings
 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
+SMTP_FROM=your-email@gmail.com
 
-# Umami Analytics
-UMAMI_URL=https://analytics.yourdomain.com
-UMAMI_HOST=analytics.yourdomain.com
-UMAMI_WEBSITE_ID=your-website-id
-UMAMI_HASH_SALT=your-random-salt
-UMAMI_DB_PASSWORD=umami-db-password
+# Required: Initial Admin Account
+ADMIN_EMAIL=admin@your-domain.com
+ADMIN_PASSWORD=change-this-password
 
-# Traefik Configuration
-TRAEFIK_HOST=traefik.yourdomain.com
-ACME_EMAIL=admin@yourdomain.com
-TRAEFIK_DASHBOARD_AUTH=admin:$2y$10$... # Use htpasswd to generate
+# 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
 
-# Docker Registry (optional)
-REGISTRY_URL=registry.yourdomain.com
-VERSION=latest
+# Optional: Customization
+SITE_NAME=PicPeak
+DEFAULT_EXPIRATION_DAYS=30
+SESSION_TIMEOUT_MINUTES=60
 
-# Monitoring
-DOMAIN=yourdomain.com
-GRAFANA_USER=admin
-GRAFANA_PASSWORD=your-grafana-password
+# Optional: Analytics (Umami)
+VITE_UMAMI_URL=
+VITE_UMAMI_WEBSITE_ID=
 
-# OAuth Configuration (optional)
-OAUTH_AUTH_URL=https://auth.yourdomain.com/oauth2/auth
-OAUTH_TOKEN_URL=https://auth.yourdomain.com/oauth2/token
-OAUTH_USER_URL=https://auth.yourdomain.com/oauth2/userinfo
-OAUTH_CLIENT_ID=photo-sharing
-OAUTH_CLIENT_SECRET=your-oauth-secret
-OAUTH_SECRET=your-random-secret
-COOKIE_DOMAIN=.yourdomain.com
-OAUTH_WHITELIST=admin@yourdomain.com
-
-# Backup Configuration (optional)
-S3_BACKUP_BUCKET=your-backup-bucket
-
-# Drone CI Configuration
-DRONE_RPC_SECRET=your-drone-secret
-DRONE_GITHUB_CLIENT_ID=your-github-client-id
-DRONE_GITHUB_CLIENT_SECRET=your-github-client-secret
+# Advanced: Performance Tuning
+NODE_ENV=production
+BCRYPT_ROUNDS=12
+RATE_LIMIT_WINDOW_MS=900000
+RATE_LIMIT_MAX_REQUESTS=100

.gitattributes-github

@@ -0,0 +1,12 @@
+# 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

@@ -0,0 +1,59 @@
+name: Mirror to GitHub
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  mirror:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0  # Full history needed for mirroring
+
+      - name: Setup Git
+        run: |
+          git config --global user.name "the-luap"
+          git config --global user.email "paul-nothaft@hotmail.de"
+
+      - name: Create filtered branch
+        run: |
+        
+          # Create a new branch for GitHub
+          git checkout --orphan -b 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
+
+        
+          # Commit the changes
+          git commit -m "Remove sensitive files for GitHub mirror" || true
+
+      - name: Push to GitHub
+        env:
+          GITHUBTOKEN: ${{ secrets.GITHUBTOKEN }}
+        run: |
+          # Add GitHub remote
+          git remote add github https://x-access-token:${GITHUBTOKEN}@github.com/the-luap/picpeak.git
+          
+          # Force push the filtered branch to GitHub main
+          git push github github-mirror:main --force

.github-mirror-exclude

@@ -0,0 +1,24 @@
+# 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/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,47 @@
+---
+name: Bug report
+about: Create a report to help us improve PicPeak
+title: '[BUG] '
+labels: 'bug'
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Environment (please complete the following information):**
+ - OS: [e.g. Ubuntu 22.04]
+ - Browser: [e.g. Chrome 120, Safari 17]
+ - PicPeak Version: [e.g. 1.0.22]
+ - Deployment Method: [e.g. Docker Compose, Manual]
+ - Database: [e.g. PostgreSQL 15, SQLite]
+
+**Logs**
+Please include relevant logs:
+```
+# Backend logs
+docker-compose logs backend | tail -50
+
+# Frontend console errors
+[paste any browser console errors]
+```
+
+**Additional context**
+Add any other context about the problem here.
+
+**Possible Solution**
+If you have an idea how to fix the issue, please describe it here.

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,11 @@
+blank_issues_enabled: false
+contact_links:
+  - name: 📚 Documentation
+    url: https://github.com/the-luap/picpeak/blob/main/DEPLOYMENT.md
+    about: Please read the documentation before opening an issue
+  - name: 💬 Discussions
+    url: https://github.com/the-luap/picpeak/discussions
+    about: Ask questions and discuss with the community
+  - name: 🔒 Security Issues
+    url: https://github.com/the-luap/picpeak/blob/main/SECURITY.md
+    about: Please review our security policy for reporting vulnerabilities

.github/ISSUE_TEMPLATE/documentation.md

@@ -0,0 +1,33 @@
+---
+name: Documentation
+about: Report issues or improvements needed in documentation
+title: '[DOCS] '
+labels: 'documentation'
+assignees: ''
+
+---
+
+**What documentation needs improvement?**
+Please specify which document or section needs attention:
+- [ ] README.md
+- [ ] DEPLOYMENT.md
+- [ ] CONTRIBUTING.md
+- [ ] API Documentation
+- [ ] Code Comments
+- [ ] Other: ___________
+
+**Describe the issue**
+What's wrong or missing in the documentation?
+
+**Suggested improvement**
+How would you improve this documentation?
+
+**Target audience**
+Who is this documentation for?
+- [ ] New users setting up PicPeak
+- [ ] Developers contributing to the project
+- [ ] System administrators
+- [ ] End users (photographers/clients)
+
+**Additional context**
+Add any other context, examples, or references here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,38 @@
+---
+name: Feature request
+about: Suggest an idea for PicPeak
+title: '[FEATURE] '
+labels: 'enhancement'
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Use Case**
+Please describe how this feature would be used:
+- Who would use it? (photographers, clients, admins)
+- When would they use it?
+- Why is it important?
+
+**Similar Features**
+Are there similar features in:
+- PicDrop
+- Scrapbook.de
+- Other photo sharing platforms
+
+**Mockups or Examples**
+If applicable, add mockups, diagrams, or links to similar implementations.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.
+
+**Implementation Ideas**
+If you have technical ideas about how this could be implemented, please share them.

.github/ISSUE_TEMPLATE/question.md

@@ -0,0 +1,26 @@
+---
+name: Question
+about: Ask a question about PicPeak
+title: '[QUESTION] '
+labels: 'question'
+assignees: ''
+
+---
+
+**Question**
+What would you like to know about PicPeak?
+
+**Context**
+Please provide context to help us answer your question better:
+- What are you trying to achieve?
+- What have you already tried?
+- Which documentation have you consulted?
+
+**Environment**
+If relevant to your question:
+- PicPeak Version:
+- Deployment Method:
+- Operating System:
+
+**Related Issues or Discussions**
+Link to any related issues, discussions, or documentation.

.github/ISSUE_TEMPLATE/security_vulnerability.md

@@ -0,0 +1,37 @@
+---
+name: Security Vulnerability
+about: Report security issues privately
+title: '[SECURITY] '
+labels: 'security'
+assignees: ''
+
+---
+
+⚠️ **IMPORTANT: For serious security vulnerabilities, please DO NOT create a public issue.**
+
+Instead, please email security@example.com with the details.
+
+For minor security improvements or questions, you can use this template:
+
+**Type of Security Issue**
+- [ ] Authentication/Authorization
+- [ ] Data Exposure
+- [ ] Input Validation
+- [ ] Configuration Issue
+- [ ] Dependency Vulnerability
+- [ ] Other: ___________
+
+**Description**
+Brief description of the security concern.
+
+**Impact**
+What could an attacker potentially do?
+
+**Steps to Reproduce**
+If applicable, how can this be reproduced?
+
+**Suggested Fix**
+If you have ideas on how to fix this issue.
+
+**References**
+Any relevant security advisories, CVEs, or documentation.

.github/pull_request_template.md

@@ -0,0 +1,49 @@
+## Description
+
+Please include a summary of the changes and which issue is fixed. Include relevant motivation and context.
+
+Fixes # (issue)
+
+## Type of change
+
+Please delete options that are not relevant.
+
+- [ ] Bug fix (non-breaking change which fixes an issue)
+- [ ] New feature (non-breaking change which adds functionality)
+- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)
+- [ ] Documentation update
+- [ ] Performance improvement
+- [ ] Code refactoring
+
+## How Has This Been Tested?
+
+Please describe the tests that you ran to verify your changes. Provide instructions so we can reproduce.
+
+- [ ] Unit tests pass (`npm test`)
+- [ ] Manual testing completed
+- [ ] Tested on Docker deployment
+- [ ] Tested on production-like environment
+
+**Test Configuration**:
+* PicPeak Version:
+* Node.js Version:
+* Database: PostgreSQL / SQLite
+* Browser:
+
+## Checklist:
+
+- [ ] My code follows the style guidelines of this project
+- [ ] I have performed a self-review of my code
+- [ ] I have commented my code, particularly in hard-to-understand areas
+- [ ] I have made corresponding changes to the documentation
+- [ ] My changes generate no new warnings
+- [ ] I have added tests that prove my fix is effective or that my feature works
+- [ ] New and existing unit tests pass locally with my changes
+- [ ] Any dependent changes have been merged and published
+- [ ] I have updated the CHANGELOG.md file
+
+## Screenshots (if appropriate):
+
+## Additional Notes:
+
+Add any additional notes, concerns, or discussion points here.

.github/workflows/release.yml

@@ -1,108 +0,0 @@
-name: Create Release
-
-on:
-  push:
-    branches:
-      - main
-    paths:
-      - 'frontend/package.json'
-      - 'backend/package.json'
-
-jobs:
-  check-version-change:
-    runs-on: ubuntu-latest
-    outputs:
-      version_changed: ${{ steps.check.outputs.changed }}
-      new_version: ${{ steps.check.outputs.version }}
-    
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 2
-
-      - name: Check if version changed
-        id: check
-        run: |
-          # Get current versions
-          FRONTEND_VERSION=$(node -p "require('./frontend/package.json').version")
-          BACKEND_VERSION=$(node -p "require('./backend/package.json').version")
-          
-          # Get previous versions
-          git checkout HEAD~1
-          PREV_FRONTEND_VERSION=$(node -p "require('./frontend/package.json').version" 2>/dev/null || echo "0.0.0")
-          PREV_BACKEND_VERSION=$(node -p "require('./backend/package.json').version" 2>/dev/null || echo "0.0.0")
-          
-          # Check if versions changed
-          if [[ "$FRONTEND_VERSION" != "$PREV_FRONTEND_VERSION" ]] || [[ "$BACKEND_VERSION" != "$PREV_BACKEND_VERSION" ]]; then
-            echo "changed=true" >> $GITHUB_OUTPUT
-            echo "version=$FRONTEND_VERSION" >> $GITHUB_OUTPUT
-          else
-            echo "changed=false" >> $GITHUB_OUTPUT
-          fi
-
-  create-release:
-    needs: check-version-change
-    if: needs.check-version-change.outputs.version_changed == 'true'
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-      
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Generate Changelog
-        id: changelog
-        run: |
-          # Get commits since last tag
-          LAST_TAG=$(git describe --tags --abbrev=0 2>/dev/null || echo "")
-          if [[ -z "$LAST_TAG" ]]; then
-            COMMITS=$(git log --oneline)
-          else
-            COMMITS=$(git log ${LAST_TAG}..HEAD --oneline)
-          fi
-          
-          # Format changelog
-          echo "## What's Changed" > changelog.md
-          echo "" >> changelog.md
-          
-          # Group commits by type
-          echo "### Features" >> changelog.md
-          echo "$COMMITS" | grep -E "^[a-f0-9]+ feat:" | sed 's/^[a-f0-9]+ /- /' >> changelog.md || echo "*No new features*" >> changelog.md
-          
-          echo "" >> changelog.md
-          echo "### Bug Fixes" >> changelog.md
-          echo "$COMMITS" | grep -E "^[a-f0-9]+ fix:" | sed 's/^[a-f0-9]+ /- /' >> changelog.md || echo "*No bug fixes*" >> changelog.md
-          
-          echo "" >> changelog.md
-          echo "### Other Changes" >> changelog.md
-          echo "$COMMITS" | grep -vE "^[a-f0-9]+ (feat|fix):" | sed 's/^[a-f0-9]+ /- /' >> changelog.md || echo "*No other changes*" >> changelog.md
-          
-          # Save changelog
-          echo "changelog<<EOF" >> $GITHUB_OUTPUT
-          cat changelog.md >> $GITHUB_OUTPUT
-          echo "EOF" >> $GITHUB_OUTPUT
-
-      - name: Create Release
-        uses: softprops/action-gh-release@v1
-        with:
-          tag_name: v${{ needs.check-version-change.outputs.new_version }}
-          name: Release v${{ needs.check-version-change.outputs.new_version }}
-          body: |
-            ## PicPeak v${{ needs.check-version-change.outputs.new_version }}
-            
-            ${{ steps.changelog.outputs.changelog }}
-            
-            ### Docker Images
-            
-            To use this release with Docker:
-            ```bash
-            docker pull ghcr.io/${{ github.repository }}/frontend:v${{ needs.check-version-change.outputs.new_version }}
-            docker pull ghcr.io/${{ github.repository }}/backend:v${{ needs.check-version-change.outputs.new_version }}
-            ```
-            
-            Or use the `latest` tag for the most recent version.
-          draft: false
-          prerelease: false
-          generate_release_notes: true

.github/workflows/version-bump.yml

@@ -1,107 +0,0 @@
-name: Automatic Version Bump
-
-on:
-  push:
-    branches:
-      - main
-  workflow_dispatch:
-    inputs:
-      version_type:
-        description: 'Version bump type'
-        required: true
-        default: 'patch'
-        type: choice
-        options:
-          - patch
-          - minor
-          - major
-
-jobs:
-  version-bump:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-      pull-requests: write
-    
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          token: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: '20'
-          
-      - name: Configure Git
-        run: |
-          git config --global user.name "GitHub Actions Bot"
-          git config --global user.email "actions@github.com"
-
-      - name: Determine version type
-        id: version_type
-        run: |
-          if [[ "${{ github.event_name }}" == "workflow_dispatch" ]]; then
-            echo "type=${{ github.event.inputs.version_type }}" >> $GITHUB_OUTPUT
-          else
-            # Auto-detect version type based on commit message
-            COMMIT_MSG="${{ github.event.head_commit.message }}"
-            if [[ "$COMMIT_MSG" == *"BREAKING CHANGE"* ]] || [[ "$COMMIT_MSG" == *"!"* ]]; then
-              echo "type=major" >> $GITHUB_OUTPUT
-            elif [[ "$COMMIT_MSG" == *"feat:"* ]] || [[ "$COMMIT_MSG" == *"feat("* ]]; then
-              echo "type=minor" >> $GITHUB_OUTPUT
-            else
-              echo "type=patch" >> $GITHUB_OUTPUT
-            fi
-          fi
-
-      - name: Bump Frontend Version
-        id: frontend_version
-        working-directory: ./frontend
-        run: |
-          npm version ${{ steps.version_type.outputs.type }} --no-git-tag-version
-          NEW_VERSION=$(node -p "require('./package.json').version")
-          echo "version=$NEW_VERSION" >> $GITHUB_OUTPUT
-          
-      - name: Bump Backend Version
-        id: backend_version
-        working-directory: ./backend
-        run: |
-          npm version ${{ steps.version_type.outputs.type }} --no-git-tag-version
-          NEW_VERSION=$(node -p "require('./package.json').version")
-          echo "version=$NEW_VERSION" >> $GITHUB_OUTPUT
-
-      - name: Update Frontend VersionInfo component
-        run: |
-          VERSION=${{ steps.frontend_version.outputs.version }}
-          sed -i "s/const FRONTEND_VERSION = '[^']*'/const FRONTEND_VERSION = '$VERSION'/" frontend/src/components/admin/VersionInfo.tsx
-
-      - name: Create Pull Request
-        uses: peter-evans/create-pull-request@v5
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          commit-message: "chore: bump version to ${{ steps.frontend_version.outputs.version }}"
-          title: "chore: bump version to ${{ steps.frontend_version.outputs.version }}"
-          body: |
-            ## Version Bump
-            
-            This PR automatically bumps the version numbers:
-            - Frontend: `${{ steps.frontend_version.outputs.version }}`
-            - Backend: `${{ steps.backend_version.outputs.version }}`
-            
-            ### Version Type: ${{ steps.version_type.outputs.type }}
-            
-            ### Files Changed:
-            - `frontend/package.json`
-            - `backend/package.json`
-            - `frontend/src/components/admin/VersionInfo.tsx`
-            
-            ---
-            *This PR was automatically created by the version bump workflow.*
-          branch: version-bump-${{ steps.frontend_version.outputs.version }}
-          delete-branch: true
-          labels: |
-            version-bump
-            automated

CI_CD_STRATEGY.md

@@ -1,118 +0,0 @@
-# CI/CD Strategy for PicPeak
-
-## Overview
-
-This document outlines the CI/CD strategy using both Gitea Actions and Drone CI to avoid conflicts and ensure proper versioning.
-
-## Pipeline Flow
-
-### 1. Development & Testing (Gitea Actions)
-- **Trigger**: Every push to `main` or `develop` branches
-- **File**: `.gitea/workflows/test.yml`
-- **Purpose**: Run tests, linting, and basic validation
-- **Actions**:
-  - Backend linting and tests
-  - Frontend linting and build
-  - Does NOT build Docker images
-
-### 2. Version Management (Gitea Actions)
-- **Trigger**: Push to `main` branch (excluding markdown files)
-- **File**: `.gitea/workflows/version-and-release.yml`
-- **Purpose**: Automatic version incrementing
-- **Actions**:
-  1. Reads current version from `package.json`
-  2. Increments patch version (e.g., 1.0.0 → 1.0.1)
-  3. Updates both backend and frontend `package.json`
-  4. Commits the version change
-  5. Creates a git tag (e.g., `v1.0.1`)
-  6. Pushes changes and tag
-
-### 3. Docker Image Building (Drone CI)
-- **Trigger**: 
-  - Push to `main` or `develop` (builds with commit SHA)
-  - New git tags (builds release versions)
-- **File**: `.drone.yml`
-- **Purpose**: Build and push Docker images
-- **Tags Created**:
-  - `latest` - Always points to newest build
-  - `{commit-sha}` - Specific commit version
-  - `{branch}-latest` - Latest for specific branch
-  - `v1.0.1` - Specific version (on tag trigger)
-
-## Why This Strategy?
-
-1. **Separation of Concerns**:
-   - Gitea Actions handles code quality and versioning
-   - Drone CI handles Docker image building
-   - No overlap or race conditions
-
-2. **Sequential Execution**:
-   - Version bump happens first
-   - Tag creation triggers Drone
-   - Docker images are built with correct version
-
-3. **Version Consistency**:
-   - Version in `package.json` matches git tag
-   - Docker images are tagged with same version
-   - No manual version management needed
-
-## Setup Requirements
-
-1. **Gitea Actions Runner**: Must be configured and running
-2. **Drone CI**: Must be connected to your Gitea instance
-3. **Secrets**: 
-   - `GITEA_TOKEN` (optional, for pushing version commits)
-   - Docker registry credentials in Drone
-
-## Version Numbering
-
-- Format: `MAJOR.MINOR.PATCH` (e.g., 1.0.0)
-- Automatic increments: PATCH version only
-- Manual increments: Edit `package.json` for MAJOR/MINOR changes
-
-## Usage
-
-1. **Regular Development**:
-   ```bash
-   git add .
-   git commit -m "feat: add new feature"
-   git push origin main
-   ```
-   - Tests run automatically
-   - Version bumps to 1.0.1
-   - Docker images built with v1.0.1 tag
-
-2. **Major/Minor Version Change**:
-   ```bash
-   # Manually edit package.json files to 2.0.0
-   git add .
-   git commit -m "feat!: major release"
-   git push origin main
-   ```
-
-3. **Skip Version Bump**:
-   - Add `[skip ci]` to commit message
-   - Or only change markdown files
-
-## Monitoring
-
-- **Gitea Actions**: Check Actions tab in Gitea
-- **Drone CI**: Check Drone dashboard
-- **Docker Registry**: Verify images are pushed with correct tags
-
-## Troubleshooting
-
-1. **Version not incrementing**:
-   - Check Gitea Actions logs
-   - Ensure runner has push permissions
-   - Verify no `[skip ci]` in commit message
-
-2. **Docker images not building**:
-   - Check Drone CI webhook configuration
-   - Verify Drone can see the repository
-   - Check Docker registry credentials
-
-3. **Conflicts**:
-   - Never run both pipelines for same task
-   - Use branch protection to prevent direct pushes
-   - Always let automation handle versioning

CODE_OF_CONDUCT.md

@@ -0,0 +1,27 @@
+# PicPeak Community Guidelines
+
+## Our Commitment
+
+We are committed to providing a welcoming and inspiring community for all photographers and developers.
+
+## Expected Behavior
+
+* Be respectful and considerate
+* Welcome newcomers and help them get started
+* Focus on what is best for the community
+* Show empathy towards other community members
+
+## Unacceptable Behavior
+
+* Trolling or insulting comments
+* Personal attacks
+* Public or private harassment
+* Publishing others' private information
+
+## 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.
+
+## Attribution
+
+This Code of Conduct is adapted from contributor-covenant.org, version 2.0.

CONTRIBUTING.md

@@ -0,0 +1,160 @@
+# Contributing to PicPeak
+
+First off, thank you for considering contributing to PicPeak! It's people like you that make PicPeak such a great tool for photographers worldwide.
+
+## 🤝 Code of Conduct
+
+This project and everyone participating in it is governed by the [PicPeak Code of Conduct](CODE_OF_CONDUCT.md). By participating, you are expected to uphold this code.
+
+## 🎯 How Can I Contribute?
+
+### Reporting Bugs
+
+Before creating bug reports, please check the existing issues as you might find out that you don't need to create one. When you are creating a bug report, please include as many details as possible:
+
+* **Use a clear and descriptive title**
+* **Describe the exact steps to reproduce the problem**
+* **Provide specific examples to demonstrate the steps**
+* **Describe the behavior you observed and what you expected**
+* **Include screenshots if possible**
+* **Include your environment details** (OS, browser, Docker version, etc.)
+
+### Suggesting Enhancements
+
+Enhancement suggestions are tracked as GitHub issues. When creating an enhancement suggestion, please include:
+
+* **Use a clear and descriptive title**
+* **Provide a detailed description of the suggested enhancement**
+* **Provide specific examples to demonstrate the enhancement**
+* **Describe the current behavior and expected behavior**
+* **Explain why this enhancement would be useful**
+
+### Your First Code Contribution
+
+Unsure where to begin? You can start by looking through these issues:
+
+* [Good first issues](https://github.com/the-luap/picpeak/labels/good%20first%20issue) - issues which should only require a few lines of code
+* [Help wanted issues](https://github.com/the-luap/picpeak/labels/help%20wanted) - issues which need extra attention
+
+### Pull Requests
+
+1. **Fork the repo** and create your branch from `main`
+2. **Install dependencies**:
+   ```bash
+   cd backend && npm install
+   cd ../frontend && npm install
+   ```
+3. **Make your changes** and ensure:
+   - Code follows the existing style
+   - Tests pass: `npm test`
+   - Linting passes: `npm run lint`
+4. **Write tests** if you've added code
+5. **Update documentation** if needed
+6. **Create a Pull Request**
+
+## 💻 Development Setup
+
+### Prerequisites
+
+- Node.js 18+
+- Docker & Docker Compose
+- Git
+
+### Local Development
+
+```bash
+# Clone your fork
+git clone https://github.com/your-username/picpeak.git
+cd picpeak
+
+# Install dependencies
+cd backend && npm install
+cd ../frontend && npm install
+
+# Set up environment
+cp .env.example .env
+# Edit .env with your settings
+
+# Start development servers
+docker-compose -f docker-compose.dev.yml up
+```
+
+### Running Tests
+
+```bash
+# Backend tests
+cd backend && npm test
+
+# Frontend tests
+cd frontend && npm test
+
+# E2E tests
+npm run test:e2e
+```
+
+## 📝 Styleguides
+
+### Git Commit Messages
+
+* Use the present tense ("Add feature" not "Added feature")
+* Use the imperative mood ("Move cursor to..." not "Moves cursor to...")
+* Limit the first line to 72 characters or less
+* Reference issues and pull requests liberally after the first line
+* Consider starting the commit message with an applicable emoji:
+  * 🎨 `:art:` when improving the format/structure of the code
+  * 🐛 `:bug:` when fixing a bug
+  * 🔥 `:fire:` when removing code or files
+  * 📝 `:memo:` when writing docs
+  * 🚀 `:rocket:` when improving performance
+  * ✨ `:sparkles:` when adding a new feature
+
+### JavaScript/TypeScript Styleguide
+
+* Use ES6+ features
+* Prefer async/await over promises
+* Use meaningful variable names
+* Add JSDoc comments for functions
+* Follow ESLint rules
+
+### React Styleguide
+
+* Use functional components with hooks
+* Keep components small and focused
+* Use TypeScript for type safety
+* Follow the existing folder structure
+* Write tests for new components
+
+## 📦 Project Structure
+
+```
+picpeak/
+├── backend/
+│   ├── src/
+│   │   ├── routes/      # API endpoints
+│   │   ├── services/    # Business logic
+│   │   ├── middleware/  # Express middleware
+│   │   └── utils/       # Utilities
+│   └── migrations/      # Database migrations
+├── frontend/
+│   ├── src/
+│   │   ├── components/  # Reusable components
+│   │   ├── pages/       # Page components
+│   │   ├── services/    # API services
+│   │   └── hooks/       # Custom hooks
+│   └── public/          # Static assets
+```
+
+## 🔄 Release Process
+
+1. Update version numbers in package.json files
+2. Update CHANGELOG.md
+3. Create a new release on GitHub
+4. Docker images are automatically built and published
+
+## 📮 Contact
+
+- Create an issue for bugs or features
+- Join discussions for questions
+- Email: picpeak@example.com for security issues
+
+Thank you for contributing! 🎉

DEPLOYMENT.md

@@ -1,483 +1,220 @@
-# Photo Sharing Platform - Production Deployment Guide
+# 🚀 PicPeak Deployment Guide
 
-This guide covers deploying the photo sharing platform using Docker Swarm, Traefik, and Drone CI/CD.
+This guide will help you deploy PicPeak in production. The entire process takes about 10-15 minutes.
 
-## Table of Contents
-- [Prerequisites](#prerequisites)
-- [Infrastructure Setup](#infrastructure-setup)
-- [Docker Swarm Setup](#docker-swarm-setup)
-- [Traefik Setup](#traefik-setup)
-- [Application Deployment](#application-deployment)
-- [CI/CD with Drone](#cicd-with-drone)
-- [Monitoring](#monitoring)
-- [Backup and Recovery](#backup-and-recovery)
-- [Troubleshooting](#troubleshooting)
+## 📋 Prerequisites
 
-## Prerequisites
+- A server with Docker and Docker Compose installed
+- A domain name (for SSL certificates)
+- SMTP credentials for sending emails
+- Basic command line knowledge
 
-### Hardware Requirements
-- **Manager Node**: 2 CPU cores, 4GB RAM, 50GB storage
-- **Worker Nodes**: 2 CPU cores, 2GB RAM, 20GB storage
-- **Storage**: SSD recommended for database and photo storage
+## 🏃 Quick Deploy (Recommended)
 
-### Software Requirements
-- Ubuntu 20.04+ or similar Linux distribution
-- Docker Engine 20.10+
-- Docker Compose 2.0+
-- Git
-- SSL certificates (automated with Let's Encrypt)
-
-### Network Requirements
-- Ports 80, 443 open for web traffic
-- Port 2377 for Swarm management
-- Ports 7946, 4789 for Swarm networking
-- Static IP or reliable dynamic DNS
-
-## Infrastructure Setup
-
-### 1. Install Docker
+### 1. Clone and Configure
 
 ```bash
-# Install Docker
-curl -fsSL https://get.docker.com | sh
+# Clone the repository
+git clone https://github.com/the-luap/picpeak.git
+cd picpeak
 
-# Add user to docker group
-sudo usermod -aG docker $USER
-
-# Enable Docker service
-sudo systemctl enable docker
-sudo systemctl start docker
-```
-
-### 2. Configure Firewall
-
-```bash
-# Allow Docker Swarm ports
-sudo ufw allow 2377/tcp
-sudo ufw allow 7946/tcp
-sudo ufw allow 7946/udp
-sudo ufw allow 4789/udp
-
-# Allow web traffic
-sudo ufw allow 80/tcp
-sudo ufw allow 443/tcp
-```
-
-## Docker Swarm Setup
-
-### 1. Initialize Swarm
-
-On the manager node:
-
-```bash
-cd deploy/scripts
-sudo ./init-swarm.sh
-```
-
-This script will:
-- Initialize Docker Swarm
-- Create overlay networks
-- Label nodes for service placement
-- Create required directories
-
-### 2. Join Worker Nodes
-
-On each worker node, run the join command displayed by the init script:
-
-```bash
-docker swarm join --token SWMTKN-1-xxx... manager-ip:2377
-```
-
-### 3. Verify Swarm
-
-```bash
-docker node ls
-```
-
-## Application Configuration
-
-### 1. Environment Setup
-
-```bash
 # Copy environment template
-cp .env.production.example .env.production
+cp .env.production.example .env
 
-# Edit with your values
-nano .env.production
+# Generate a secure JWT secret
+echo "JWT_SECRET=$(openssl rand -base64 32)" >> .env
+
+# Edit configuration
+nano .env
 ```
 
-Required configurations:
-- Domain names for frontend, backend, and services
-- SMTP credentials for email
-- Database passwords
-- JWT secrets
+### 2. Required Environment Variables
 
-### 2. Create Docker Secrets
+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
-cd deploy/scripts
-./create-secrets.sh
+# 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
 ```
 
-This will create all required secrets in Docker Swarm. Save the generated passwords!
+## 🔧 Configuration Options
 
-## Traefik Setup
+### Storage Settings
 
-### 1. Deploy Traefik
+```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
-cd deploy/traefik
+# Backup database and photos
+./scripts/backup.sh
 
-# Create traefik network
-docker network create --driver overlay traefik-public
-
-# Deploy Traefik stack
-docker stack deploy -c docker-compose.traefik.yml traefik
+# Backups are stored in ./backups/
 ```
 
-### 2. Verify Traefik
+### Update
 
 ```bash
-# Check service status
-docker service ls | grep traefik
+# Pull latest changes
+git pull
 
-# View logs
-docker service logs traefik_traefik
+# Rebuild and restart
+docker-compose -f docker-compose.prod.yml up -d --build
 ```
 
-Access Traefik dashboard at: `https://traefik.yourdomain.com/dashboard/`
-
-## Application Deployment
-
-### 1. Build Images (if using local registry)
+### Logs
 
 ```bash
-# Build frontend
-cd frontend
-docker build -t photo-sharing-frontend:latest .
+# View all logs
+docker-compose logs
 
-# Build backend
-cd ../backend
-docker build -t photo-sharing-backend:latest .
+# View specific service
+docker-compose logs backend
+docker-compose logs frontend
 ```
 
-### 2. Deploy Application Stack
-
-```bash
-cd deploy/scripts
-./deploy.sh
-```
-
-Options:
-- `--env FILE`: Specify environment file
-- `--registry URL`: Docker registry URL
-- `--version VERSION`: Image version to deploy
-
-### 3. Verify Deployment
-
-```bash
-# Check all services
-docker service ls
-
-# Check specific service
-docker service ps photo-sharing_backend
-
-# View logs
-docker service logs photo-sharing_backend -f
-```
-
-### 4. Run Database Migrations
-
-The deploy script automatically runs migrations, but you can run manually:
-
-```bash
-docker exec $(docker ps -q -f name=photo-sharing_backend) npm run migrate
-```
-
-## CI/CD with Drone
-
-### 1. Drone Server Setup
-
-Deploy Drone server on your CI infrastructure:
-
-```bash
-docker run \
-  --volume=/var/lib/drone:/data \
-  --env=DRONE_GITHUB_CLIENT_ID=your-id \
-  --env=DRONE_GITHUB_CLIENT_SECRET=your-secret \
-  --env=DRONE_RPC_SECRET=your-rpc-secret \
-  --env=DRONE_SERVER_HOST=drone.yourdomain.com \
-  --env=DRONE_SERVER_PROTO=https \
-  --publish=80:80 \
-  --publish=443:443 \
-  --restart=always \
-  --detach=true \
-  --name=drone \
-  drone/drone:2
-```
-
-### 2. Drone Runner Setup
-
-On build servers:
-
-```bash
-docker run -d \
-  -v /var/run/docker.sock:/var/run/docker.sock \
-  -e DRONE_RPC_PROTO=https \
-  -e DRONE_RPC_HOST=drone.yourdomain.com \
-  -e DRONE_RPC_SECRET=your-rpc-secret \
-  -e DRONE_RUNNER_CAPACITY=2 \
-  -e DRONE_RUNNER_NAME=runner-1 \
-  -p 3000:3000 \
-  --restart always \
-  --name runner \
-  drone/drone-runner-docker:1
-```
-
-### 3. Repository Setup
-
-1. Enable repository in Drone UI
-2. Add secrets in Drone:
-   - `docker_username`
-   - `docker_password`
-   - `docker_registry`
-   - `staging_swarm_host`
-   - `staging_swarm_user`
-   - `staging_swarm_key`
-   - `prod_swarm_host`
-   - `prod_swarm_user`
-   - `prod_swarm_key`
-   - `slack_webhook`
-
-### 4. Deployment Workflow
-
-- Push to `develop` → Deploy to staging
-- Create tag → Deploy to production
-- Automatic rollback on failure
-
-## Monitoring
-
-### 1. Deploy Monitoring Stack
-
-```bash
-cd deploy/monitoring
-
-# Deploy monitoring services
-docker stack deploy -c docker-compose.monitoring.yml monitoring
-```
-
-### 2. Access Services
-
-- Grafana: `https://grafana.yourdomain.com`
-- Prometheus: `https://prometheus.yourdomain.com`
-- Alertmanager: `https://alerts.yourdomain.com`
-
-### 3. Configure Alerts
-
-Create alert rules in `deploy/monitoring/alerts/`:
-
-```yaml
-groups:
-  - name: photo-sharing
-    rules:
-      - alert: ServiceDown
-        expr: up{job="photo-sharing-backend"} == 0
-        for: 5m
-        annotations:
-          summary: "Photo sharing backend is down"
-```
-
-## Backup and Recovery
-
-### 1. Automated Backups
-
-Set up cron job for automated backups:
-
-```bash
-# Edit crontab
-crontab -e
-
-# Add daily backup at 2 AM
-0 2 * * * /opt/photo-sharing/deploy/scripts/backup.sh
-```
-
-### 2. Manual Backup
-
-```bash
-cd deploy/scripts
-./backup.sh
-```
-
-### 3. Restore from Backup
-
-```bash
-# Extract backup
-tar -xzf backup-20240615-020000.tar.gz
-
-# Restore database
-docker exec -i $(docker ps -q -f name=photo-sharing_db) \
-  psql -U postgres photo_sharing < backup-20240615-020000/database.sql
-
-# Restore photos
-tar -xzf backup-20240615-020000/photos.tar.gz -C /opt/photo-sharing/
-
-# Restore volumes
-docker run --rm \
-  -v photo-sharing_app-data:/data \
-  -v $(pwd)/backup-20240615-020000:/backup \
-  alpine tar -xzf /backup/volume-photo-sharing_app-data.tar.gz -C /data
-```
-
-## Maintenance
-
-### 1. Scaling Services
-
-```bash
-# Scale backend to 5 replicas
-docker service scale photo-sharing_backend=5
-
-# Scale frontend to 3 replicas
-docker service scale photo-sharing_frontend=3
-```
-
-### 2. Rolling Updates
-
-```bash
-# Update backend image
-docker service update \
-  --image registry.yourdomain.com/photo-sharing-backend:v2.0 \
-  photo-sharing_backend
-```
-
-### 3. Drain Node for Maintenance
-
-```bash
-# Drain node
-docker node update --availability drain worker-1
-
-# Perform maintenance...
-
-# Activate node
-docker node update --availability active worker-1
-```
-
-## Troubleshooting
+## 🚨 Troubleshooting
 
 ### Common Issues
 
-#### 1. Service Won't Start
+**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 service ps photo-sharing_backend --no-trunc
+docker-compose ps
 
-# View detailed logs
-docker service logs photo-sharing_backend --details
+# Test backend API
+curl https://your-domain.com/api/health
+
+# Check disk space
+df -h storage/
 ```
 
-#### 2. Database Connection Issues
-```bash
-# Check database logs
-docker service logs photo-sharing_db
+## 🐳 Alternative Deployment Methods
 
-# Test connection
-docker exec $(docker ps -q -f name=photo-sharing_db) \
-  pg_isready -U postgres
-```
+### Using Docker Swarm
 
-#### 3. Traefik Certificate Issues
-```bash
-# Check Traefik logs
-docker service logs traefik_traefik | grep acme
+For high availability deployments, see [Docker Swarm Setup](deploy/README.md).
 
-# Remove and regenerate certificates
-rm -rf /opt/traefik/letsencrypt/acme.json
-docker service update --force traefik_traefik
-```
+### Manual Installation
 
-#### 4. Storage Issues
-```bash
-# Check disk usage
-df -h
+If you prefer not to use Docker:
 
-# Clean up Docker
-docker system prune -a
-```
+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
 
-### Debug Mode
+## 📞 Support
 
-Enable debug logging:
+- 📘 [Documentation](https://github.com/the-luap/picpeak)
+- 🐛 [Report Issues](https://github.com/the-luap/picpeak/issues)
+- 💬 [Discussions](https://github.com/the-luap/picpeak/discussions)
 
-```bash
-# Update service with debug logging
-docker service update \
-  --env-add LOG_LEVEL=debug \
-  photo-sharing_backend
-```
+---
 
-### Health Checks
-
-```bash
-# Check all endpoints
-curl -f https://photos.yourdomain.com/health
-curl -f https://api.photos.yourdomain.com/api/health
-curl -f https://traefik.yourdomain.com/ping
-```
-
-## Security Best Practices
-
-1. **Regular Updates**
-   - Keep Docker and system packages updated
-   - Update application dependencies regularly
-   - Monitor security advisories
-
-2. **Access Control**
-   - Use strong passwords for all services
-   - Enable 2FA where possible
-   - Restrict SSH access to specific IPs
-   - Use Docker secrets for sensitive data
-
-3. **Network Security**
-   - Use internal networks for service communication
-   - Enable firewall rules
-   - Use TLS for all external communication
-   - Regular security scans with Trivy
-
-4. **Backup Security**
-   - Encrypt backups at rest
-   - Test restore procedures regularly
-   - Store backups in multiple locations
-   - Rotate old backups
-
-## Performance Tuning
-
-1. **Database Optimization**
-   ```sql
-   -- Add indexes for common queries
-   CREATE INDEX idx_photos_event_id ON photos(event_id);
-   CREATE INDEX idx_access_logs_event_id ON access_logs(event_id);
-   ```
-
-2. **Image Optimization**
-   - Use CDN for static assets
-   - Enable aggressive caching
-   - Optimize image sizes before upload
-
-3. **Service Limits**
-   ```yaml
-   deploy:
-     resources:
-       limits:
-         cpus: '2'
-         memory: 1G
-       reservations:
-         cpus: '0.5'
-         memory: 256M
-   ```
-
-## Support
-
-For issues and questions:
-- Check logs: `docker service logs <service_name>`
-- Review documentation: [README.md](README.md)
-- Check monitoring dashboards
-- Contact: admin@yourdomain.com
+**Need help?** Open an issue on GitHub and we'll assist you!

PRODUCTION_DEPLOYMENT.md

@@ -0,0 +1,98 @@
+# 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

@@ -0,0 +1,312 @@
+# 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-LOCAL.md

@@ -1,130 +0,0 @@
-# 🚀 Quick Local Development Setup
-
-Get the photo sharing platform running locally in under 2 minutes!
-
-## Prerequisites
-- Docker Desktop installed and running
-- Git
-- 4GB RAM available
-
-## Quick Start
-
-```bash
-# 1. Clone the repository
-git clone <your-repo-url>
-cd picpeak
-
-# 2. Start everything
-./start-local.sh
-```
-
-That's it! 🎉
-
-## What You Get
-
-| Service | URL | Description |
-|---------|-----|-------------|
-| Frontend (Dev) | http://localhost:3002 | React app with hot reload |
-| Frontend (Prod) | http://localhost:3000 | Production build |
-| Backend API | http://localhost:3001 | Express API |
-| Mailhog | http://localhost:8025 | Email testing UI |
-
-## Default Credentials
-
-- **Admin Login**: Check `ADMIN_CREDENTIALS.txt` after first setup
-- **Test Gallery**: 
-  - Create via Admin Panel
-  - Set your own secure password
-
-## Common Tasks
-
-### View Logs
-```bash
-docker-compose -f docker-compose.local.yml logs -f
-```
-
-### Stop Everything
-```bash
-./stop-local.sh
-```
-
-### Reset Database
-```bash
-docker-compose -f docker-compose.local.yml exec backend npm run migrate
-```
-
-### Add Test Photos
-1. Create a gallery in the admin panel
-2. Get the gallery slug (e.g., `wedding-smith-2024`)
-3. Add photos to: `./storage/events/active/wedding-smith-2024/`
-4. Photos appear automatically!
-
-### Access Backend Shell
-```bash
-docker-compose -f docker-compose.local.yml exec backend sh
-```
-
-## Development Workflow
-
-1. **Frontend Development** (Port 3002)
-   - Hot reload enabled
-   - Edit files in `./frontend/src`
-   - Changes appear instantly
-
-2. **Backend Development** (Port 3001)
-   - Nodemon watches for changes
-   - Edit files in `./backend/src`
-   - Server restarts automatically
-
-3. **Email Testing**
-   - All emails go to Mailhog
-   - View at http://localhost:8025
-   - No real emails sent!
-
-## Troubleshooting
-
-### Backend won't start
-```bash
-# Check logs
-docker-compose -f docker-compose.local.yml logs backend
-
-# Rebuild
-docker-compose -f docker-compose.local.yml build backend
-```
-
-### Frontend build issues
-```bash
-# Clear cache and rebuild
-docker-compose -f docker-compose.local.yml exec frontend-dev npm run build
-```
-
-### Port conflicts
-Edit `docker-compose.local.yml` and change the port mappings:
-- Backend: Change `3001:3000` to `XXXX:3000`
-- Frontend: Change `3002:5173` to `YYYY:5173`
-
-### Reset everything
-```bash
-# Stop and remove all data
-docker-compose -f docker-compose.local.yml down -v
-rm -rf data storage logs
-./start-local.sh
-```
-
-## Tips
-
-- 📧 Check Mailhog for all emails
-- 🔄 Frontend auto-refreshes on save
-- 📁 SQLite DB at `./data/photo_sharing.db`
-- 🖼️ Photos in `./storage/events/active/`
-- 📝 Logs in `./logs/`
-
-## Next Steps
-
-1. Create your first gallery via Admin Panel
-2. Upload some test photos
-3. Test the gallery with password
-4. Check expiration warnings
-5. View emails in Mailhog
-
-Happy coding! 🎨

README.md

@@ -1,32 +1,164 @@
-# Photo Sharing Platform
+# 📸 PicPeak - Open Source Photo Sharing for Events
 
-A secure, self-hosted photo sharing platform designed for weddings and events. Features automatic expiration, email notifications, and simple file-based management.
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Docker](https://img.shields.io/badge/docker-%230db7ed.svg?style=flat&logo=docker&logoColor=white)](https://www.docker.com/)
+[![Node.js](https://img.shields.io/badge/node.js-6DA55F?style=flat&logo=node.js&logoColor=white)](https://nodejs.org/)
+[![React](https://img.shields.io/badge/react-%2320232a.svg?style=flat&logo=react&logoColor=%2361DAFB)](https://reactjs.org/)
 
-## Features
+**PicPeak** is a powerful, self-hosted open-source alternative to commercial photo-sharing platforms like PicDrop.com and Scrapbook.de. Designed specifically for photographers and event organizers, PicPeak makes it simple to share beautiful, time-limited photo galleries with clients while maintaining full control over your data and branding.
 
-- 🔒 Password Protected Galleries
-- ⏰ Automatic Expiration
-- 📧 Email Notifications
-- 📁 Simple File Management
-- 📊 Analytics Integration
-- 🎨 Customizable Themes
-- 📱 Mobile Responsive
-- ⚡ Docker Ready
+![PicPeak Gallery Preview](https://github.com/the-luap/picpeak/assets/placeholder-hero.png)
 
-## Quick Start
+## 🌟 Why Choose PicPeak?
 
-1. Clone the repository
-2. Run `./scripts/install.sh`
-3. Configure `.env` file
-4. Setup SSL: `./scripts/setup-ssl.sh`
-5. Start: `docker-compose -f docker-compose.prod.yml up -d`
+Unlike expensive SaaS solutions, PicPeak gives you:
 
-Default credentials: Check ADMIN_CREDENTIALS.txt after first setup
+- **💰 No Monthly Fees** - One-time setup, unlimited galleries
+- **🔒 Complete Data Control** - Your photos stay on your server
+- **🎨 White-Label Ready** - Full branding customization
+- **📱 Mobile-First Design** - Beautiful on all devices
+- **🚀 Lightning Fast** - Optimized performance and caching
+- **🌍 Multi-Language** - Built-in i18n support (EN, DE)
 
-## Documentation
+## ✨ Key Features
 
-See DEPLOYMENT.md for detailed deployment instructions.
+### For Photographers
+- 📁 **Drag & Drop Upload** - Simply drop photos into folders
+- ⏰ **Auto-Expiring Galleries** - Set expiration dates (default: 30 days)
+- 🔐 **Password Protection** - Secure client galleries
+- 📧 **Automated Emails** - Creation confirmations and expiration warnings
+- 📊 **Analytics Dashboard** - Track views, downloads, and engagement
+- 🎨 **Custom Themes** - Match your brand perfectly
 
-## License
+### For Clients
+- 🖼️ **Beautiful Galleries** - Clean, modern interface
+- 📱 **Mobile Optimized** - Swipe through photos on any device
+- ⬇️ **Bulk Downloads** - Download all photos with one click
+- 🔍 **Smart Search** - Find photos quickly
+- 📤 **Guest Uploads** - Optional client photo uploads
 
-MIT License
+### Technical Excellence
+- 🐳 **Docker Ready** - Deploy in minutes
+- 🔄 **Auto-Processing** - Automatic thumbnail generation
+- 💾 **Smart Storage** - Automatic archiving of expired galleries
+- 🛡️ **Security First** - JWT auth, rate limiting, CORS protection
+- 📈 **Scalable** - From small studios to large agencies
+
+## 🚀 Quick Start
+
+Get PicPeak running in under 5 minutes:
+
+```bash
+# Clone the repository
+git clone https://github.com/the-luap/picpeak.git
+cd picpeak
+
+# Copy environment template
+cp .env.example .env
+
+# Edit configuration (required: JWT_SECRET)
+nano .env
+
+# Start with Docker Compose
+docker-compose up -d
+
+# Access at http://localhost:3005
+```
+
+## 📖 Documentation
+
+- 📘 [**Deployment Guide**](DEPLOYMENT.md) - Detailed installation instructions
+- 🤝 [**Contributing**](CONTRIBUTING.md) - How to contribute
+- 📜 [**License**](LICENSE) - MIT License
+- 🔒 [**Security**](SECURITY.md) - Security policies
+- 📋 [**Code of Conduct**](CODE_OF_CONDUCT.md) - Community guidelines
+
+## 🎯 Use Cases
+
+Perfect for:
+- 💒 **Wedding Photographers** - Share ceremony photos securely
+- 🎂 **Event Photography** - Birthday parties, corporate events
+- 📸 **Portrait Studios** - Client galleries with download limits
+- 🏢 **Corporate Events** - Internal photo sharing with branding
+- 🎓 **School Photography** - Secure parent access with expiration
+
+## 🏗️ Tech Stack
+
+- **Backend**: Node.js, Express, SQLite/PostgreSQL
+- **Frontend**: React, Tailwind CSS, Framer Motion
+- **Storage**: File-based with automatic archiving
+- **Email**: SMTP with customizable templates
+- **Analytics**: Privacy-focused with Umami integration
+
+## 🤝 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.
+
+See our [Contributing Guide](CONTRIBUTING.md) for details.
+
+## 📊 Comparison with Alternatives
+
+| Feature | PicPeak | PicDrop | Scrapbook.de |
+|---------|---------|---------|--------------|
+| Self-Hosted | ✅ | ❌ | ❌ |
+| Custom Branding | ✅ Full | Limited | Limited |
+| Monthly Cost | $0 | $29-199 | €19-99 |
+| Storage Limit | Unlimited* | 50-500GB | 100-1000GB |
+| Client Uploads | ✅ | ✅ | ✅ |
+| API Access | ✅ | Paid | ❌ |
+| Open Source | ✅ | ❌ | ❌ |
+
+*Limited only by your server storage
+
+## 🛡️ Security
+
+PicPeak takes security seriously:
+- 🔐 Password hashing with bcrypt
+- 🎫 JWT-based authentication
+- 🚦 Rate limiting on all endpoints
+- 🛡️ CORS protection
+- 📝 Activity logging
+- 🔒 Secure file access
+
+Found a security issue? Please email security@example.com
+
+## 📸 Screenshots
+
+<details>
+<summary>View Gallery Examples</summary>
+
+### Admin Dashboard
+![Admin Dashboard](https://github.com/the-luap/picpeak/assets/placeholder-admin.png)
+
+### Client Gallery View
+![Gallery View](https://github.com/the-luap/picpeak/assets/placeholder-gallery.png)
+
+### Mobile Experience
+![Mobile View](https://github.com/the-luap/picpeak/assets/placeholder-mobile.png)
+
+</details>
+
+## 🙏 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.
+
+## 📄 License
+
+PicPeak is released under the [MIT License](LICENSE). Use it freely for personal or commercial projects.
+
+## 🚀 Ready to Get Started?
+
+1. ⭐ **Star this repository** to show your support
+2. 📖 Read the [Deployment Guide](DEPLOYMENT.md)
+3. 🐛 Report issues or request features
+4. 🤝 Join our community and contribute!
+
+---
+
+<p align="center">
+  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="https://github.com/the-luap/picpeak/issues">Support</a>
+</p>

SECURITY.md

@@ -0,0 +1,85 @@
+# Security Policy
+
+## Supported Versions
+
+We release patches for security vulnerabilities. Currently supported versions:
+
+| Version | Supported          |
+| ------- | ------------------ |
+| 1.x.x   | :white_check_mark: |
+| < 1.0   | :x:                |
+
+## Reporting a Vulnerability
+
+We take the security of PicPeak seriously. If you have discovered a security vulnerability, please follow these steps:
+
+### 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)
+
+### 3. You can expect:
+- Acknowledgment within 48 hours
+- Regular updates on our progress
+- Credit in the fix announcement (unless you prefer to remain anonymous)
+
+## Security Measures
+
+PicPeak implements several security measures:
+
+### Authentication & Authorization
+- JWT-based authentication with secure token storage
+- bcrypt password hashing with configurable rounds
+- Role-based access control for admin functions
+- Session timeout management
+
+### Input Validation
+- All user inputs are validated and sanitized
+- SQL injection prevention through parameterized queries
+- XSS protection via Content Security Policy
+- File upload restrictions and validation
+
+### Rate Limiting
+- API rate limiting to prevent abuse
+- Brute force protection on authentication endpoints
+- Configurable limits per endpoint
+
+### Data Protection
+- HTTPS enforcement in production
+- Secure cookie settings
+- CORS configuration
+- Sensitive data encryption
+
+### Infrastructure
+- Regular dependency updates
+- Security headers (HSTS, X-Frame-Options, etc.)
+- Activity logging for audit trails
+- Automated backups
+
+## Best Practices for Deployment
+
+1. **Always use HTTPS** in production
+2. **Change default passwords** immediately
+3. **Keep dependencies updated** regularly
+4. **Configure firewall rules** appropriately
+5. **Monitor logs** for suspicious activity
+6. **Backup regularly** and test restoration
+
+## Vulnerability Disclosure
+
+We believe in responsible disclosure. Once a vulnerability is fixed:
+
+1. We'll publish a security advisory
+2. Credit researchers (with permission)
+3. Detail the impact and mitigation steps
+4. Release patches for all supported versions
+
+## Contact
+
+- Security issues: security@example.com
+- General support: https://github.com/the-luap/picpeak/issues
+
+Thank you for helping keep PicPeak and its users safe!

SETUP_GUIDE.md

@@ -1,252 +0,0 @@
-# PicPeak - Complete Setup Guide
-
-## Repository Created Successfully! 🎉
-
-Your PicPeak repository has been created at:
-**https://gitea.nothaft.cloud/paul/picpeak**
-
-## What's Been Created
-
-I've uploaded the core files needed to run the application:
-
-### ✅ Created Files:
-- `.gitignore` - Git ignore rules
-- `.dockerignore` - Docker ignore rules
-- `.env.example` - Environment configuration template
-- `docker-compose.yml` - Development Docker setup
-- `docker-compose.prod.yml` - Production Docker setup
-- `backend/` - Core backend files including:
-  - `package.json` - Dependencies
-  - `server.js` - Main server file
-  - `Dockerfile` - Backend container config
-  - Core routes and services
-- `setup-remaining-files.sh` - Script to create remaining files
-
-## Next Steps to Complete Setup
-
-### 1. Clone the Repository
-```bash
-git clone https://gitea.local.nothaft.cloud/paul/picpeak.git
-cd picpeak
-```
-
-### 2. Run the Setup Script
-```bash
-chmod +x setup-remaining-files.sh
-./setup-remaining-files.sh
-```
-
-This will create all remaining directories and files needed.
-
-### 3. Create Critical Service Files
-
-Due to the large number of files, I've created the most important ones. You'll need to add these remaining backend services:
-
-#### backend/src/services/expirationChecker.js
-```javascript
-const cron = require('node-cron');
-const { db } = require('../database/db');
-const { archiveEvent } = require('./archiveService');
-const logger = require('../utils/logger');
-
-function startExpirationChecker() {
-  // Check every hour for expired events
-  cron.schedule('0 * * * *', async () => {
-    await checkExpirations();
-  });
-  
-  logger.info('Expiration checker started');
-}
-
-async function checkExpirations() {
-  try {
-    const now = new Date();
-    const warningDate = new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000);
-    
-    // Check for events needing warning emails
-    const eventsNeedingWarning = await db('events')
-      .where('is_active', true)
-      .where('is_archived', false)
-      .where('expires_at', '<=', warningDate)
-      .where('expires_at', '>', now);
-    
-    for (const event of eventsNeedingWarning) {
-      const existingWarning = await db('email_queue')
-        .where('event_id', event.id)
-        .where('email_type', 'warning')
-        .first();
-      
-      if (!existingWarning) {
-        await queueExpirationWarning(event);
-      }
-    }
-    
-    // Check for expired events
-    const expiredEvents = await db('events')
-      .where('is_active', true)
-      .where('is_archived', false)
-      .where('expires_at', '<=', now);
-    
-    for (const event of expiredEvents) {
-      await handleExpiredEvent(event);
-    }
-    
-  } catch (error) {
-    logger.error('Error checking expirations:', error);
-  }
-}
-
-async function queueExpirationWarning(event) {
-  const daysRemaining = Math.ceil((new Date(event.expires_at) - new Date()) / (1000 * 60 * 60 * 24));
-  
-  await db('email_queue').insert({
-    event_id: event.id,
-    recipient_email: event.host_email,
-    email_type: 'warning',
-    email_data: JSON.stringify({
-      event_name: event.event_name,
-      days_remaining: daysRemaining,
-      share_link: event.share_link
-    })
-  });
-  
-  logger.info(`Queued expiration warning for event ${event.slug}`);
-}
-
-async function handleExpiredEvent(event) {
-  try {
-    await db('events').where('id', event.id).update({ is_active: false });
-    
-    await db('email_queue').insert([
-      {
-        event_id: event.id,
-        recipient_email: event.host_email,
-        email_type: 'expiration',
-        email_data: JSON.stringify({
-          event_name: event.event_name
-        })
-      },
-      {
-        event_id: event.id,
-        recipient_email: event.admin_email,
-        email_type: 'expiration',
-        email_data: JSON.stringify({
-          event_name: event.event_name,
-          event_slug: event.slug
-        })
-      }
-    ]);
-    
-    await archiveEvent(event);
-    
-    logger.info(`Handled expiration for event ${event.slug}`);
-  } catch (error) {
-    logger.error(`Error handling expired event ${event.slug}:`, error);
-  }
-}
-
-module.exports = { startExpirationChecker };
-```
-
-### 4. Create Frontend Files
-
-The frontend needs these key files in `frontend/src/`:
-
-#### App.js
-```javascript
-import React from 'react';
-import { Routes, Route, Navigate } from 'react-router-dom';
-import { AuthProvider } from './contexts/AuthContext';
-import ProtectedRoute from './components/ProtectedRoute';
-
-// Pages
-import Login from './pages/Login';
-import Gallery from './pages/Gallery';
-import AdminLogin from './pages/admin/Login';
-import AdminDashboard from './pages/admin/Dashboard';
-
-function App() {
-  return (
-    <AuthProvider>
-      <Routes>
-        <Route path="/" element={<Navigate to="/gallery" />} />
-        <Route path="/gallery/:slug/:token?" element={<Gallery />} />
-        <Route path="/login/:slug" element={<Login />} />
-        <Route path="/admin/login" element={<AdminLogin />} />
-        <Route path="/admin" element={
-          <ProtectedRoute>
-            <AdminDashboard />
-          </ProtectedRoute>
-        } />
-      </Routes>
-    </AuthProvider>
-  );
-}
-
-export default App;
-```
-
-### 5. Install Dependencies
-
-```bash
-# Backend
-cd backend
-npm install
-
-# Frontend
-cd ../frontend
-npm install
-```
-
-### 6. Configure Environment
-
-Copy `.env.example` to `.env` and update with your settings:
-```bash
-cp .env.example .env
-nano .env
-```
-
-### 7. Start Development Environment
-
-```bash
-# From root directory
-docker-compose up
-```
-
-- Backend: http://localhost:3000
-- Frontend: http://localhost:3001
-- MailHog: http://localhost:8025
-
-## Key Features Implemented
-
-- ✅ Password-protected galleries
-- ✅ Automatic expiration with email warnings
-- ✅ File-based photo management
-- ✅ ZIP archiving on expiration
-- ✅ Separate admin and public interfaces
-- ✅ Email notifications at all stages
-- ✅ Mobile-responsive design
-- ✅ Docker deployment ready
-
-## Production Deployment
-
-1. Update `.env` with production values
-2. Run `./scripts/install.sh` on your server
-3. Configure SSL with `./scripts/setup-ssl.sh`
-4. Start with `docker-compose -f docker-compose.prod.yml up -d`
-
-## Need Help?
-
-The complete implementation includes:
-- Backend API with all routes
-- React frontend with admin panel
-- Email service with templates
-- Automatic file watching
-- Expiration checking
-- Archive service
-- Docker configuration
-- Deployment scripts
-
-All core functionality from your PRD has been implemented. You may need to create some additional UI components based on your specific design preferences.
-
-Default admin credentials: **admin / admin123** (change immediately!)

TODO.md

@@ -1,47 +0,0 @@
-# TODO - Open Items Before Release
-
-## Priority Items
-
-- [ ] **Gallery Mobile View** 
-  - Logout button should only show logo icon (no text)
-  - If photo upload is enabled, move upload button inside menu (not on top bar)
-  - Top bar should show: logo (left), gallery title (center), event date + expiration date
-
-- [ ] **Gallery Preview** 
-  - Preview should correctly reflect the selected grid layout style
-  - Add grid style selector above current top bar
-  - Selector should match the style of event template settings grid selector
-
-- [ ] **Hero Grid Layout** 
-  - Top bar: only menu and logout buttons
-  - Title + logo displayed centered on hero photo
-  - Event date and expiration date also on hero photo
-  - No logo/title in top bar
-
-- [ ] **Logo Testing** - Test new PicPeak logos across all grid styles
-
-- [ ] **Welcome Message** 
-  - Add welcome message to email template when creating new event
-  - Use as personal message in the email
-
-- [ ] **Gallery Upload Function**
-  - Fix scrolling in upload popup when multiple images selected
-  - Save/Cancel buttons unreachable due to incorrect scroll formatting
-
-- [ ] **Watermarks** - Test watermark functionality, styling, and image application
-
-- [ ] **Dashboard Activities** - Remove "show all" link from latest activities widget
-
-- [ ] **Security Audit** - Perform security review and code audit
-
-- [ ] **Drone CI/CD** - Update drone.yaml configuration
-
-- [ ] **Version Management** - Implement automatic version updates on commits/builds
-
-## Completed Items
-
-_(Move completed items here with date)_
-
----
-
-Last updated: 2025-07-10

backend/.env.example

@@ -1,33 +1,41 @@
-NODE_ENV=development
+# Backend Environment Variables Example
+# Copy this file to .env and update with your values
+
+# Application
+NODE_ENV=production
 PORT=3000
 
-# URLs
-ADMIN_URL=http://localhost:3000
-FRONTEND_URL=http://localhost:3001
-
 # Security
-JWT_SECRET=dev-secret-key
+JWT_SECRET=your-very-secure-jwt-secret-at-least-32-characters-long
+
+# URLs
+ADMIN_URL=https://yourdomain.com
+FRONTEND_URL=https://yourdomain.com
+
+# Database Configuration
+DATABASE_CLIENT=pg
+DB_HOST=db
+DB_PORT=5432
+DB_USER=picpeak
+DB_PASSWORD=your-secure-database-password
+DB_NAME=picpeak
 
 # Email Configuration
-SMTP_HOST=mailhog
-SMTP_PORT=1025
+SMTP_HOST=smtp.example.com
+SMTP_PORT=587
 SMTP_SECURE=false
-SMTP_USER=
-SMTP_PASS=
-EMAIL_FROM=noreply@localhost
+SMTP_USER=your-smtp-username
+SMTP_PASS=your-smtp-password
+EMAIL_FROM=noreply@yourdomain.com
 
-# Storage Paths (relative to project root)
-STORAGE_PATH=./storage
-EVENTS_PATH=./storage/events
-ARCHIVE_PATH=./storage/events/archived
+# Storage Paths (Docker)
+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
 
 # Logging
-LOG_LEVEL=info
-
-# Database (for production, consider PostgreSQL)
-DATABASE_CLIENT=sqlite3
-DATABASE_PATH=./data/photo_sharing.db
-
-# Umami Analytics (optional)
-UMAMI_URL=
-UMAMI_WEBSITE_ID=
+LOG_LEVEL=info

backend/ACTIVATE_AUTH_V2.md

@@ -1,137 +0,0 @@
-# Quick Guide: Activate Authentication V2 Fixes
-
-## Step 1: Install Dependency
-```bash
-cd backend
-npm install zxcvbn@4.4.2
-```
-
-## Step 2: Add to Docker & Run Migration
-```bash
-# Rebuild Docker with new dependency
-docker-compose down
-docker-compose up -d --build
-
-# Run migration for token revocation
-docker exec wedding-photo-sharing-backend-1 node /app/scripts/add-token-revocation-tables.js
-```
-
-## Step 3: Update server.js
-
-### 3.1 Fix Rate Limiting (Line ~10)
-```javascript
-// Add after other requires
-const { createSecureSkipFunction, logRateLimitHit } = require('./src/utils/rateLimitSecurity');
-```
-
-### 3.2 Update Rate Limiter (Line ~59)
-```javascript
-const limiter = rateLimit({
-  windowMs: 15 * 60 * 1000,
-  max: process.env.NODE_ENV === 'development' ? 1000 : 100,
-  skip: createSecureSkipFunction(), // CHANGE THIS LINE
-  handler: (req, res) => {
-    logRateLimitHit(req, res); // ADD THIS
-    res.status(429).json({
-      error: 'Too many requests from this IP, please try again later.'
-    });
-  }
-});
-```
-
-### 3.3 Update Auth Limiter (Line ~81)
-```javascript
-const authLimiter = rateLimit({
-  windowMs: 15 * 60 * 1000,
-  max: 5,
-  skipSuccessfulRequests: true, // ADD THIS
-  handler: (req, res) => {
-    logRateLimitHit(req, res); // ADD THIS
-    res.status(429).json({
-      error: 'Too many login attempts, please try again later.',
-      retryAfter: res.getHeader('Retry-After')
-    });
-  }
-});
-```
-
-### 3.4 Change Auth Routes (Line ~22)
-```javascript
-// Change from:
-const authRoutes = require('./src/routes/auth-enhanced');
-// To:
-const authRoutes = require('./src/routes/auth-enhanced-v2');
-```
-
-### 3.5 Add Token Revocation (After line ~147)
-```javascript
-// After initializeCleanupJob();
-const { initializeRevocationCleanup } = require('./src/utils/tokenRevocation');
-initializeRevocationCleanup();
-```
-
-## Step 4: Update Middleware Imports
-
-In files that import adminAuth:
-```javascript
-// Change from:
-const { adminAuth } = require('../middleware/auth-enhanced');
-// To:
-const { adminAuth } = require('../middleware/auth-enhanced-v2');
-```
-
-## Step 5: Update adminEvents.js
-
-Add password validation to event creation:
-```javascript
-// At top of file
-const { validatePasswordInContext, getBcryptRounds } = require('../utils/passwordValidation');
-
-// In POST route, after extracting password, add:
-const passwordValidation = validatePasswordInContext(password, 'gallery', {
-  eventName: event_name
-});
-
-if (!passwordValidation.valid) {
-  return res.status(400).json({ 
-    error: 'Password does not meet security requirements',
-    details: passwordValidation.errors,
-    score: passwordValidation.score,
-    feedback: passwordValidation.feedback
-  });
-}
-
-// Change password hashing to:
-const password_hash = await bcrypt.hash(password, getBcryptRounds());
-```
-
-## Step 6: Add Environment Variable
-```bash
-# In .env file
-BCRYPT_ROUNDS=12
-```
-
-## Step 7: Restart & Test
-```bash
-docker-compose restart backend
-
-# Test rate limiting
-curl -H "Authorization: Bearer invalid" http://localhost:3001/api/admin/events
-
-# Test password validation  
-node scripts/test-auth-v2-fixes.js
-```
-
-## Verification Checklist
-- [ ] zxcvbn installed
-- [ ] Token revocation tables created
-- [ ] Rate limiting can't be bypassed
-- [ ] Weak passwords rejected
-- [ ] Password change works
-- [ ] No errors in logs
-
-## Rollback
-If issues occur:
-1. Revert server.js changes
-2. Restart backend
-3. All new features are additive, so existing functionality remains

backend/AUTH_FLAWS_ANALYSIS.md

@@ -1,64 +0,0 @@
-# Authentication & Authorization Flaws Analysis
-
-## Already Fixed ✅
-
-1. **Missing Token Type Validation** ✅
-   - Fixed in `auth-enhanced.js` line 31
-   - Checks `decoded.type !== 'admin'`
-   - Prevents gallery tokens from accessing admin endpoints
-
-2. **No Audit Logging** ✅
-   - Added `login_attempts` table
-   - Tracks all login attempts with IP, user agent, timestamp
-   - Automatic cleanup of old records
-
-3. **Account Lockout Protection** ✅
-   - Lockout after 5 failed attempts
-   - 30-minute lockout duration
-   - Prevents brute force attacks
-
-4. **Basic Session Management** ✅
-   - Added session timeout middleware
-   - Tracks active sessions
-   - Can invalidate sessions
-
-## Still Needs Fixing ❌
-
-### 1. Weak Password Requirements 🔴
-- **Current**: No minimum length validation
-- **Required**: Minimum 12 characters + complexity
-- **Risk**: Vulnerable to brute force
-
-### 2. Rate Limiting Bypass 🔴
-- **Current**: Invalid JWT bypasses rate limiting
-- **Location**: `server.js:64-71`
-- **Risk**: Attackers can spam with invalid tokens
-
-### 3. No Password Complexity 🟡
-- **Current**: Any 6+ character password accepted
-- **Required**: Upper, lower, number, special char
-- **Risk**: Weak passwords
-
-### 4. No Token Revocation 🟡
-- **Current**: Tokens valid until expiration
-- **Required**: Blacklist/revocation mechanism
-- **Risk**: Can't invalidate compromised tokens
-
-### 5. Fixed Bcrypt Rounds 🟡
-- **Current**: Hardcoded to 10 rounds
-- **Required**: Configurable (12-14 recommended)
-- **Risk**: May become insufficient over time
-
-### 6. In-Memory Session Storage 🟡
-- **Current**: Sessions stored in memory
-- **Required**: Redis or database storage
-- **Risk**: Lost on restart, not scalable
-
-## Priority Fixes
-
-1. **Rate Limiting Bypass** (Critical)
-2. **Password Requirements** (High)
-3. **Password Complexity** (High)
-4. **Token Revocation** (Medium)
-5. **Bcrypt Rounds** (Medium)
-6. **Session Storage** (Low - for scalability)

backend/AUTH_SECURITY_INTEGRATION.md

@@ -1,216 +0,0 @@
-# Authentication Security Integration Guide
-
-## How The Enhanced Security Works
-
-### 1. Login Flow with Protection
-
-```
-User Login Attempt
-    ↓
-Rate Limiter (5 attempts/15 min)
-    ↓
-Account Lockout Check
-    ↓
-reCAPTCHA Verification
-    ↓
-Credentials Validation
-    ↓
-Track Login Attempt
-    ↓
-Generate Enhanced JWT
-```
-
-### 2. Token Structure
-
-**Before** (Basic JWT):
-```json
-{
-  "id": 1,
-  "type": "admin",
-  "exp": 1234567890
-}
-```
-
-**After** (Enhanced JWT):
-```json
-{
-  "id": 1,
-  "username": "admin",
-  "type": "admin",
-  "ip": "192.168.1.100",
-  "loginTime": 1234567890,
-  "exp": 1234567890,
-  "iss": "picpeak-auth"
-}
-```
-
-### 3. Security Layers
-
-1. **Network Level**:
-   - Rate limiting (express-rate-limit)
-   - CORS restrictions
-   - Helmet security headers
-
-2. **Application Level**:
-   - Account lockout (5 attempts)
-   - reCAPTCHA validation
-   - Login attempt tracking
-
-3. **Session Level**:
-   - JWT with expiration
-   - Session timeout tracking
-   - IP validation
-   - Password change detection
-
-4. **Database Level**:
-   - Bcrypt password hashing
-   - Audit trail (login_attempts)
-   - Secure token storage
-
-## Integration Points
-
-### Server.js Changes
-
-```javascript
-// Add after database initialization
-const { initializeCleanupJob } = require('./src/utils/authSecurity');
-initializeCleanupJob();
-
-// Update route import (when ready)
-const authRoutes = require('./src/routes/auth-enhanced');
-```
-
-### Middleware Updates
-
-For routes requiring enhanced security:
-```javascript
-// Change from:
-router.get('/sensitive', adminAuth, handler);
-
-// To:
-const { adminAuth } = require('../middleware/auth-enhanced');
-router.get('/sensitive', adminAuth, handler);
-```
-
-### Frontend Integration
-
-1. **Handle New Error Codes**:
-```javascript
-// Lockout error
-if (error.response?.status === 423) {
-  const retryAfter = error.response.data.retryAfter;
-  showError(`Account locked. Try again in ${retryAfter} seconds`);
-}
-
-// Session expired
-if (error.response?.data?.code === 'SESSION_TIMEOUT') {
-  redirectToLogin();
-}
-```
-
-2. **Implement Logout**:
-```javascript
-async function logout() {
-  await api.post('/auth/logout');
-  clearToken();
-  redirectToLogin();
-}
-```
-
-3. **Check Session Status**:
-```javascript
-async function checkSession() {
-  const response = await api.get('/auth/session');
-  if (!response.data.valid) {
-    redirectToLogin();
-  }
-}
-```
-
-## Configuration
-
-### Environment Variables
-No new environment variables required. Uses existing:
-- `JWT_SECRET` - For token signing
-- `NODE_ENV` - For environment detection
-
-### Security Settings
-In `authSecurity.js`:
-```javascript
-const MAX_LOGIN_ATTEMPTS = 5;       // Attempts before lockout
-const LOCKOUT_DURATION = 30 * 60 * 1000;  // 30 minutes
-const ATTEMPT_WINDOW = 15 * 60 * 1000;    // 15 minute window
-```
-
-## Monitoring & Maintenance
-
-### Daily Monitoring
-```sql
--- Check for brute force attempts
-SELECT identifier, COUNT(*) as attempts,
-       MAX(attempt_time) as last_attempt
-FROM login_attempts
-WHERE success = 0
-AND attempt_time > datetime('now', '-24 hours')
-GROUP BY identifier
-HAVING COUNT(*) > 10
-ORDER BY attempts DESC;
-```
-
-### Weekly Review
-```sql
--- Suspicious activity patterns
-SELECT DATE(attempt_time) as date,
-       COUNT(DISTINCT identifier) as unique_users,
-       COUNT(DISTINCT ip_address) as unique_ips,
-       COUNT(*) as total_attempts,
-       SUM(CASE WHEN success = 0 THEN 1 ELSE 0 END) as failed_attempts
-FROM login_attempts
-WHERE attempt_time > datetime('now', '-7 days')
-GROUP BY DATE(attempt_time)
-ORDER BY date DESC;
-```
-
-### Automated Cleanup
-The system automatically cleans up login attempts older than 7 days to prevent database bloat.
-
-## Troubleshooting
-
-### User Locked Out
-```sql
--- Check lockout status
-SELECT * FROM login_attempts 
-WHERE identifier = 'user@example.com'
-AND attempt_time > datetime('now', '-30 minutes')
-ORDER BY attempt_time DESC;
-
--- Clear lockout
-DELETE FROM login_attempts 
-WHERE identifier = 'user@example.com'
-AND success = 0;
-```
-
-### Token Issues
-```javascript
-// Debug token in browser console
-const token = localStorage.getItem('token');
-const decoded = JSON.parse(atob(token.split('.')[1]));
-console.log('Token expires:', new Date(decoded.exp * 1000));
-console.log('Token IP:', decoded.ip);
-```
-
-## Security Best Practices
-
-1. **Monitor Failed Attempts**: Set up alerts for excessive failures
-2. **Review IP Patterns**: Look for geographic anomalies
-3. **Rotate JWT Secret**: Periodically update in production
-4. **Update Dependencies**: Keep auth libraries current
-5. **Test Lockouts**: Regularly verify protection works
-
-## Future Enhancements
-
-1. **Two-Factor Authentication**: Database columns already added
-2. **IP Whitelist**: For admin accounts
-3. **Device Fingerprinting**: Enhanced session security
-4. **OAuth Integration**: Social login options
-5. **WebAuthn/Passkeys**: Passwordless authentication

backend/AUTH_SECURITY_MIGRATION.md

@@ -1,221 +0,0 @@
-# Authentication Security Enhancement Migration Guide
-
-## Overview
-This guide provides a safe migration path to enhance authentication security without disrupting the production system.
-
-## Security Enhancements Implemented
-
-### 1. Account Lockout Protection
-- Locks accounts after 5 failed login attempts within 15 minutes
-- 30-minute lockout duration
-- Prevents brute force attacks
-
-### 2. Login Attempt Tracking
-- Records all login attempts (success/failure)
-- Tracks IP addresses and user agents
-- Enables security monitoring and alerting
-
-### 3. Enhanced Token Security
-- Added issuer validation
-- IP address tracking in tokens
-- Login time tracking
-- Password change detection
-
-### 4. Generic Error Messages
-- Prevents user enumeration attacks
-- Returns "Invalid credentials" for all auth failures
-
-### 5. Logout Endpoint
-- Properly invalidates sessions
-- Clears server-side session tracking
-
-## Migration Steps
-
-### Step 1: Database Migrations (Low Risk)
-
-First, run the new migrations to add required tables/columns:
-
-```bash
-cd backend
-
-# Run new migrations
-npx knex migrate:latest
-
-# Verify migrations
-npx knex migrate:status
-```
-
-This adds:
-- `login_attempts` table
-- `password_changed_at` column to `admin_users`
-- `last_login_ip` column to `admin_users`
-
-### Step 2: Deploy Enhanced Auth Utilities (Low Risk)
-
-The new files don't affect existing functionality:
-- `src/utils/authSecurity.js` - New security utilities
-- `src/middleware/auth-enhanced.js` - Enhanced auth middleware
-- `src/routes/auth-enhanced.js` - Enhanced auth routes
-
-### Step 3: Gradual Rollout Plan
-
-#### Phase 1: Testing (Day 1)
-1. Deploy code but keep using existing auth routes
-2. Test enhanced routes in parallel:
-   ```bash
-   # Test existing endpoint
-   curl -X POST http://localhost:3001/api/auth/admin/login
-   
-   # Test enhanced endpoint (if added to routes)
-   curl -X POST http://localhost:3001/api/auth-enhanced/admin/login
-   ```
-
-#### Phase 2: Monitoring (Days 2-3)
-1. Add the auth security initialization to server.js:
-   ```javascript
-   // In server.js, after database initialization
-   const { initializeCleanupJob } = require('./src/utils/authSecurity');
-   initializeCleanupJob();
-   ```
-
-2. Monitor logs for any issues
-3. Check login_attempts table is populating
-
-#### Phase 3: Switch Routes (Day 4)
-1. Update route imports in server.js:
-   ```javascript
-   // Change from:
-   const authRoutes = require('./src/routes/auth');
-   
-   // To:
-   const authRoutes = require('./src/routes/auth-enhanced');
-   ```
-
-2. Update middleware imports where needed:
-   ```javascript
-   // Change from:
-   const { adminAuth } = require('./src/middleware/auth');
-   
-   // To:
-   const { adminAuth } = require('./src/middleware/auth-enhanced');
-   ```
-
-### Step 4: Rollback Plan
-
-If issues occur at any phase:
-
-```bash
-# Quick rollback - revert route imports
-# In server.js, change back to:
-const authRoutes = require('./src/routes/auth');
-const { adminAuth } = require('./src/middleware/auth');
-
-# Restart application
-docker-compose restart backend
-# or
-pm2 restart picpeak-backend
-```
-
-## Testing Checklist
-
-### Before Production Deployment:
-
-1. **Test Normal Login Flow**:
-   ```bash
-   # Should work normally
-   curl -X POST http://localhost:3001/api/auth/admin/login \
-     -H "Content-Type: application/json" \
-     -d '{"username":"admin","password":"correct-password"}'
-   ```
-
-2. **Test Account Lockout**:
-   ```bash
-   # Make 5 failed attempts
-   for i in {1..5}; do
-     curl -X POST http://localhost:3001/api/auth/admin/login \
-       -H "Content-Type: application/json" \
-       -d '{"username":"admin","password":"wrong-password"}'
-   done
-   
-   # 6th attempt should return lockout error
-   ```
-
-3. **Test Logout**:
-   ```bash
-   curl -X POST http://localhost:3001/api/auth/logout \
-     -H "Authorization: Bearer YOUR_TOKEN"
-   ```
-
-4. **Test Session Info**:
-   ```bash
-   curl http://localhost:3001/api/auth/session \
-     -H "Authorization: Bearer YOUR_TOKEN"
-   ```
-
-## Configuration Options
-
-### Adjusting Security Settings
-
-In `src/utils/authSecurity.js`, you can adjust:
-```javascript
-const MAX_LOGIN_ATTEMPTS = 5;  // Number of attempts before lockout
-const LOCKOUT_DURATION = 30 * 60 * 1000;  // Lockout time in ms
-const ATTEMPT_WINDOW = 15 * 60 * 1000;  // Time window for counting attempts
-```
-
-## Monitoring
-
-### Check Login Attempts:
-```sql
--- Recent failed attempts
-SELECT * FROM login_attempts 
-WHERE success = false 
-ORDER BY attempt_time DESC 
-LIMIT 20;
-
--- Accounts with multiple failures
-SELECT identifier, COUNT(*) as failed_attempts
-FROM login_attempts
-WHERE success = false
-AND attempt_time > datetime('now', '-1 hour')
-GROUP BY identifier
-HAVING COUNT(*) > 3;
-```
-
-### Monitor Locked Accounts:
-```sql
--- Check currently locked accounts
-SELECT identifier, COUNT(*) as attempts,
-       MAX(attempt_time) as last_attempt
-FROM login_attempts
-WHERE success = false
-AND attempt_time > datetime('now', '-15 minutes')
-GROUP BY identifier
-HAVING COUNT(*) >= 5;
-```
-
-## Security Benefits
-
-1. **Prevents Brute Force**: Account lockout after failed attempts
-2. **Audit Trail**: Complete login history for security analysis
-3. **Session Security**: Tokens invalidated on password change
-4. **IP Monitoring**: Detect suspicious login patterns
-5. **User Privacy**: Generic errors prevent user enumeration
-
-## Notes
-
-- Old tokens remain valid until expiration
-- No immediate user impact
-- Gradual rollout minimizes risk
-- Full rollback possible at any stage
-
-## Support
-
-Monitor logs after deployment:
-```bash
-# Docker
-docker-compose logs -f backend | grep -E "(auth|login|security)"
-
-# PM2
-pm2 logs picpeak-backend | grep -E "(auth|login|security)"
-```

backend/AUTH_SECURITY_ROLLBACK.md

@@ -1,187 +0,0 @@
-# Authentication Security Enhancement Rollback Plan
-
-## Quick Rollback Steps
-
-### Immediate Rollback (< 2 minutes)
-
-If auth issues occur after deployment, follow these steps:
-
-```bash
-# 1. SSH into production server
-ssh your-server
-
-# 2. Navigate to backend directory
-cd /path/to/picpeak/backend
-
-# 3. Revert route changes in server.js
-# Change from:
-# const authRoutes = require('./src/routes/auth-enhanced');
-# Back to:
-# const authRoutes = require('./src/routes/auth');
-
-# 4. Revert middleware if changed
-# Change from:
-# const { adminAuth } = require('./src/middleware/auth-enhanced');
-# Back to:
-# const { adminAuth } = require('./src/middleware/auth');
-
-# 5. Restart application
-docker-compose restart backend
-# OR
-pm2 restart picpeak-backend
-```
-
-## Rollback Scenarios
-
-### Scenario 1: Users Can't Login
-
-**Symptoms**:
-- All login attempts fail
-- Generic "Invalid credentials" error
-- Admin panel inaccessible
-
-**Quick Fix**:
-```bash
-# Revert to original auth routes
-cd backend
-git checkout HEAD -- server.js
-docker-compose restart backend
-```
-
-### Scenario 2: Account Lockout Issues
-
-**Symptoms**:
-- Legitimate users locked out
-- "Account temporarily locked" errors
-
-**Quick Fix**:
-```sql
--- Clear all lockouts
-DELETE FROM login_attempts WHERE success = false;
-
--- Or clear specific user
-DELETE FROM login_attempts 
-WHERE identifier = 'username_or_email' 
-AND success = false;
-```
-
-### Scenario 3: Token Validation Errors
-
-**Symptoms**:
-- "Invalid token" errors
-- Existing sessions broken
-- API calls failing
-
-**Quick Fix**:
-```javascript
-// In auth middleware, temporarily disable strict validation
-// Comment out issuer validation:
-// issuer: 'picpeak-auth'
-
-// Just use basic verification:
-const decoded = jwt.verify(token, process.env.JWT_SECRET);
-```
-
-### Scenario 4: Database Migration Issues
-
-**Symptoms**:
-- Application won't start
-- Database errors in logs
-
-**Rollback Migration**:
-```bash
-# Rollback last 2 migrations
-npx knex migrate:rollback --all
-npx knex migrate:up 014_add_default_welcome_message.js
-
-# Or manually fix:
-sqlite3 database.db
-DROP TABLE IF EXISTS login_attempts;
-ALTER TABLE admin_users DROP COLUMN password_changed_at;
-ALTER TABLE admin_users DROP COLUMN last_login_ip;
-```
-
-## Verification After Rollback
-
-1. **Test Admin Login**:
-   ```bash
-   curl -X POST http://your-domain/api/auth/admin/login \
-     -H "Content-Type: application/json" \
-     -d '{"username":"admin","password":"your-password"}'
-   ```
-
-2. **Test Gallery Access**:
-   ```bash
-   curl -X POST http://your-domain/api/auth/gallery/verify \
-     -H "Content-Type: application/json" \
-     -d '{"slug":"test-gallery","password":"gallery-password"}'
-   ```
-
-3. **Check Logs**:
-   ```bash
-   # No auth errors should appear
-   docker-compose logs backend | tail -100 | grep -i error
-   ```
-
-## File Restoration
-
-If files were modified, restore from backup:
-
-```bash
-# List of files that can be safely reverted
-git checkout HEAD -- src/middleware/auth.js
-git checkout HEAD -- src/routes/auth.js
-git checkout HEAD -- server.js
-
-# Remove new files (safe to delete)
-rm -f src/utils/authSecurity.js
-rm -f src/middleware/auth-enhanced.js
-rm -f src/routes/auth-enhanced.js
-rm -f migrations/015_add_login_attempts_table.js
-rm -f migrations/016_add_auth_security_columns.js
-```
-
-## Emergency SQL Fixes
-
-```sql
--- Clear all security restrictions
-DELETE FROM login_attempts;
-
--- Reset admin password if locked out
-UPDATE admin_users 
-SET password_hash = '$2b$10$YourKnownGoodHashHere'
-WHERE username = 'admin';
-
--- Remove security columns if causing issues
--- (SQLite doesn't support DROP COLUMN easily, so ignore)
-```
-
-## Monitoring After Rollback
-
-```bash
-# Watch for stability
-watch -n 5 'docker-compose logs backend | tail -20'
-
-# Check active connections
-netstat -an | grep :3001 | wc -l
-
-# Monitor CPU/Memory
-docker stats wedding-photo-sharing-backend-1
-```
-
-## Prevention for Next Attempt
-
-Before re-attempting the security enhancement:
-
-1. **Test in staging environment first**
-2. **Implement gradual rollout with feature flags**
-3. **Add backwards compatibility for tokens**
-4. **Create admin bypass for lockouts**
-5. **Set up monitoring alerts**
-
-## Contact
-
-If rollback fails:
-1. Check `backend/logs/error.log`
-2. Restore from last known good backup
-3. Use original auth implementation as reference

backend/AUTH_SECURITY_SUMMARY.md

@@ -1,119 +0,0 @@
-# Authentication Security Enhancement Summary
-
-## Security Issues Fixed
-
-### 1. ✅ Account Lockout Protection
-- **Issue**: No protection against brute force attacks
-- **Fix**: Lock account after 5 failed attempts in 15 minutes
-- **Files**: `authSecurity.js`, `login_attempts` table
-
-### 2. ✅ Login Attempt Tracking
-- **Issue**: No audit trail for security monitoring
-- **Fix**: Track all login attempts with IP, user agent, timestamp
-- **Database**: New `login_attempts` table
-
-### 3. ✅ Generic Error Messages
-- **Issue**: Different errors could reveal if username exists
-- **Fix**: Always return "Invalid credentials"
-- **Impact**: Prevents user enumeration attacks
-
-### 4. ✅ Session Management
-- **Issue**: No way to invalidate tokens/logout
-- **Fix**: Added `/api/auth/logout` endpoint
-- **Fix**: Session tracking with timeout
-
-### 5. ✅ Enhanced Token Security
-- **Issue**: Basic JWT with minimal claims
-- **Fix**: Added issuer, IP, loginTime claims
-- **Fix**: Token invalidation on password change
-
-## Implementation Details
-
-### New Files Created
-```
-backend/
-├── src/
-│   ├── utils/
-│   │   └── authSecurity.js (122 lines)
-│   ├── middleware/
-│   │   └── auth-enhanced.js (169 lines)
-│   └── routes/
-│       └── auth-enhanced.js (244 lines)
-├── migrations/
-│   ├── 015_add_login_attempts_table.js
-│   └── 016_add_auth_security_columns.js
-└── scripts/
-    └── test-auth-security.js
-```
-
-### Database Changes
-1. **login_attempts** table:
-   - Tracks all authentication attempts
-   - Enables lockout and monitoring
-
-2. **admin_users** additions:
-   - `password_changed_at` - Invalidate old tokens
-   - `last_login_ip` - Security monitoring
-   - `two_factor_enabled` - Future 2FA support
-
-## Security Improvements
-
-### Before
-- ❌ Unlimited login attempts
-- ❌ No audit trail
-- ❌ User enumeration possible
-- ❌ No session invalidation
-- ❌ Basic JWT validation
-
-### After
-- ✅ Brute force protection
-- ✅ Complete audit trail
-- ✅ Generic error messages
-- ✅ Logout functionality
-- ✅ Enhanced token validation
-- ✅ IP tracking
-- ✅ Password change detection
-
-## Deployment Safety
-
-### Gradual Rollout
-1. **Phase 1**: Deploy code (no impact)
-2. **Phase 2**: Run migrations (adds tables only)
-3. **Phase 3**: Initialize tracking (monitoring only)
-4. **Phase 4**: Switch routes (activates protection)
-
-### Risk Mitigation
-- ✅ Backward compatible
-- ✅ No breaking changes
-- ✅ Existing tokens remain valid
-- ✅ Quick rollback possible
-- ✅ Comprehensive testing
-
-## Testing Results
-```
-✅ All 10 security tests passed
-✅ Generic errors working
-✅ Lockout logic verified
-✅ Token enhancements tested
-```
-
-## Next Steps
-
-1. **Deploy database migrations** (safe)
-2. **Deploy new files** (no impact)
-3. **Test in staging** if available
-4. **Gradual production rollout**
-5. **Monitor login_attempts table**
-
-## Monitoring Commands
-
-```bash
-# Check failed login attempts
-sqlite3 database.db "SELECT identifier, COUNT(*) as attempts FROM login_attempts WHERE success = 0 AND attempt_time > datetime('now', '-1 hour') GROUP BY identifier"
-
-# View recent login activity
-sqlite3 database.db "SELECT * FROM login_attempts ORDER BY attempt_time DESC LIMIT 10"
-
-# Check locked accounts
-sqlite3 database.db "SELECT identifier FROM login_attempts WHERE success = 0 GROUP BY identifier HAVING COUNT(*) >= 5"
-```

backend/AUTH_V2_DEPLOYMENT_PLAN.md

@@ -1,232 +0,0 @@
-# Authentication Security V2 Deployment Plan
-
-## Overview
-This deployment adds remaining authentication security fixes identified in the security scan.
-
-## New Security Features
-
-### 1. Rate Limiting Bypass Fix ✅
-- **File**: `src/utils/rateLimitSecurity.js`
-- **Fix**: Properly validates JWT before skipping rate limit
-- **Impact**: Prevents attackers from bypassing with invalid tokens
-
-### 2. Password Complexity Requirements ✅
-- **File**: `src/utils/passwordValidation.js`
-- **Features**:
-  - Minimum 12 characters (up from 6)
-  - Must contain: uppercase, lowercase, numbers, special chars
-  - Password strength scoring (zxcvbn)
-  - Context-aware validation (admin vs gallery)
-  - Configurable bcrypt rounds
-
-### 3. Token Revocation System ✅
-- **Files**: `src/utils/tokenRevocation.js`, migration
-- **Features**:
-  - Revoke individual tokens
-  - Revoke all user tokens
-  - Automatic cleanup of expired revocations
-  - Check on every auth request
-
-### 4. Enhanced Auth Routes ✅
-- **File**: `src/routes/auth-enhanced-v2.js`
-- **Features**:
-  - Password change endpoint with validation
-  - Real-time password strength checking
-  - Better error responses with feedback
-
-## Dependencies to Install
-
-```bash
-npm install zxcvbn@4.4.2
-```
-
-## Database Migrations
-
-```sql
--- Token revocation tables
-CREATE TABLE revoked_tokens (
-  id INTEGER PRIMARY KEY,
-  token_id TEXT UNIQUE NOT NULL,
-  user_id INTEGER,
-  token_type TEXT,
-  revoked_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-  expires_at TIMESTAMP NOT NULL,
-  reason TEXT,
-  metadata TEXT
-);
-
-CREATE TABLE user_token_revocations (
-  user_id INTEGER PRIMARY KEY,
-  revoked_at TIMESTAMP NOT NULL,
-  reason TEXT
-);
-```
-
-## Deployment Steps
-
-### Phase 1: Preparation (Day 1)
-
-1. **Install Dependencies**
-   ```bash
-   cd backend
-   npm install zxcvbn@4.4.2
-   ```
-
-2. **Run Migrations**
-   ```bash
-   docker exec wedding-photo-sharing-backend-1 node scripts/add-token-revocation-tables.js
-   ```
-
-3. **Deploy New Files** (No impact yet)
-   - `rateLimitSecurity.js`
-   - `passwordValidation.js`
-   - `tokenRevocation.js`
-   - `auth-enhanced-v2.js`
-
-### Phase 2: Testing (Day 2)
-
-1. **Test Rate Limiting Fix**
-   ```bash
-   # Try with invalid token
-   curl -H "Authorization: Bearer invalid-token" \
-     http://localhost:3001/api/admin/events
-   # Should apply rate limiting
-   ```
-
-2. **Test Password Validation**
-   ```bash
-   node -e "
-     const {validatePassword} = require('./src/utils/passwordValidation');
-     console.log(validatePassword('weak'));
-     console.log(validatePassword('StrongP@ssw0rd123'));
-   "
-   ```
-
-### Phase 3: Gradual Activation (Day 3)
-
-#### Step 1: Update Server.js for Rate Limiting
-```javascript
-// Replace in server.js
-const { createSecureSkipFunction, logRateLimitHit } = require('./src/utils/rateLimitSecurity');
-
-const limiter = rateLimit({
-  windowMs: 15 * 60 * 1000,
-  max: process.env.NODE_ENV === 'development' ? 1000 : 100,
-  skip: createSecureSkipFunction(), // NEW: Secure skip function
-  handler: (req, res) => {
-    logRateLimitHit(req, res); // NEW: Logging
-    res.status(429).json({
-      error: 'Too many requests from this IP, please try again later.'
-    });
-  }
-});
-```
-
-#### Step 2: Update Auth Routes
-```javascript
-// In server.js, change to v2
-const authRoutes = require('./src/routes/auth-enhanced-v2');
-```
-
-#### Step 3: Update Middleware
-```javascript
-// Update imports to use v2
-const { adminAuth } = require('./src/middleware/auth-enhanced-v2');
-```
-
-#### Step 4: Update Event Creation
-```javascript
-// In adminEvents.js, add password validation
-const { validatePasswordInContext, getBcryptRounds } = require('../utils/passwordValidation');
-
-// In the POST route, add validation before hashing
-```
-
-#### Step 5: Initialize Token Revocation
-```javascript
-// In server.js, after initializeCleanupJob()
-const { initializeRevocationCleanup } = require('./src/utils/tokenRevocation');
-initializeRevocationCleanup();
-```
-
-## Environment Variables
-
-Add to `.env`:
-```bash
-# Bcrypt rounds (12-14 recommended)
-BCRYPT_ROUNDS=12
-```
-
-## Testing Checklist
-
-- [ ] Invalid tokens can't bypass rate limiting
-- [ ] Weak passwords are rejected
-- [ ] Password change requires strong password
-- [ ] Tokens can be revoked
-- [ ] Revoked tokens are rejected
-- [ ] Admin passwords require higher strength
-- [ ] Gallery passwords check for event name
-
-## Rollback Plan
-
-### Quick Rollback
-```bash
-# Revert server.js changes
-git checkout HEAD -- server.js
-
-# Restart
-docker-compose restart backend
-```
-
-### Rollback Specific Features
-
-1. **Rate Limiting**: Revert to old skip function
-2. **Password Validation**: Remove validation calls
-3. **Token Revocation**: Skip revocation checks
-
-## Monitoring
-
-### Check Password Validation Failures
-```bash
-docker-compose logs backend | grep "Password validation failed"
-```
-
-### Check Rate Limiting
-```bash
-docker-compose logs backend | grep "Rate limit"
-```
-
-### Check Token Revocations
-```bash
-docker exec wedding-photo-sharing-backend-1 node -e "
-  const {db} = require('./src/database/db');
-  db('revoked_tokens').count().first()
-    .then(r => console.log('Revoked tokens:', r['count(*)'] || 0))
-    .then(() => db.destroy());
-"
-```
-
-## Security Improvements
-
-| Feature | Before | After |
-|---------|---------|--------|
-| Rate Limiting | Can bypass with invalid token | Properly validated |
-| Password Length | 6 chars | 12 chars minimum |
-| Password Complexity | None | Upper+lower+number+special |
-| Password Strength | Not checked | zxcvbn scoring |
-| Token Revocation | Not possible | Full revocation system |
-| Bcrypt Rounds | Fixed (10) | Configurable (12) |
-
-## Performance Considerations
-
-1. **Password Validation**: ~50ms per check (zxcvbn)
-2. **Token Revocation**: Adds 1 DB query per request
-3. **Bcrypt Rounds**: 12 rounds = ~250ms (vs 100ms for 10)
-
-## Success Criteria
-
-- ✅ No invalid tokens bypass rate limiting
-- ✅ All new passwords meet complexity requirements  
-- ✅ Password change works with validation
-- ✅ Tokens can be revoked on logout
-- ✅ No performance degradation > 100ms

backend/AUTH_V2_FIXES_SUMMARY.md

@@ -1,114 +0,0 @@
-# Authentication V2 Security Fixes Summary
-
-## What We Fixed
-
-### 1. ✅ Rate Limiting Bypass (CRITICAL)
-**Issue**: Invalid JWT tokens could bypass rate limiting  
-**Fix**: Created `rateLimitSecurity.js` that properly validates tokens  
-**Impact**: Attackers can no longer spam requests with invalid tokens
-
-### 2. ✅ Weak Password Requirements (HIGH)
-**Issue**: Only 6 character minimum, no complexity  
-**Fix**: Created `passwordValidation.js` with:
-- 12 character minimum
-- Must have: uppercase, lowercase, numbers, special chars
-- Password strength scoring (zxcvbn)
-- Context-aware validation (prevents username/event name in password)
-- Configurable bcrypt rounds (default 12)
-**Impact**: Much stronger passwords, resistant to brute force
-
-### 3. ✅ Token Revocation (MEDIUM)
-**Issue**: No way to invalidate tokens before expiration  
-**Fix**: Created `tokenRevocation.js` with full revocation system
-- Individual token revocation
-- User-level revocation (all tokens)
-- Automatic cleanup
-- Database tables for tracking
-**Impact**: Can now invalidate compromised tokens
-
-### 4. ✅ Enhanced Authentication Routes
-**Fix**: Created `auth-enhanced-v2.js` with:
-- Password change endpoint with validation
-- Real-time password strength API
-- Better error messages with feedback
-**Impact**: Users get helpful password feedback
-
-## Files Created
-
-```
-backend/
-├── src/
-│   ├── utils/
-│   │   ├── rateLimitSecurity.js (118 lines)
-│   │   ├── passwordValidation.js (267 lines)
-│   │   └── tokenRevocation.js (127 lines)
-│   ├── routes/
-│   │   ├── auth-enhanced-v2.js (332 lines)
-│   │   └── adminEvents-enhanced.js (partial)
-│   └── middleware/
-│       └── auth-enhanced-v2.js (updated)
-├── migrations/
-│   └── 017_add_token_revocation_tables.js
-├── scripts/
-│   ├── add-token-revocation-tables.js
-│   └── test-auth-v2-fixes.js
-└── server-enhanced.js (partial)
-```
-
-## Deployment Status
-
-### Ready to Deploy ✅
-- All code written and tested
-- Migration scripts ready
-- Test scripts available
-- Rollback plan documented
-
-### Required Actions
-1. Install `zxcvbn` dependency
-2. Run token revocation migration
-3. Update server.js with new imports
-4. Update auth routes to v2
-5. Test thoroughly before production
-
-## Security Improvements Summary
-
-| Vulnerability | Severity | Status | Fix |
-|--------------|----------|---------|-----|
-| Rate Limiting Bypass | 🔴 Critical | ✅ Fixed | Proper token validation |
-| Weak Passwords | 🔴 High | ✅ Fixed | 12 chars + complexity |
-| No Token Revocation | 🟡 Medium | ✅ Fixed | Full revocation system |
-| Fixed Bcrypt Rounds | 🟡 Medium | ✅ Fixed | Configurable (env var) |
-| No Password Feedback | 🟡 Low | ✅ Fixed | Strength API endpoint |
-
-## What's Still Pending
-
-From the original auth flaws, these remain lower priority:
-1. **In-memory session storage** - Works fine for single instance
-2. **No refresh tokens** - 24h tokens are reasonable for this use case
-3. **Fixed token expiration** - Could make configurable later
-
-## Testing Commands
-
-```bash
-# Test rate limiting fix
-node scripts/test-auth-v2-fixes.js
-
-# Test password validation
-node -e "
-  const {validatePassword} = require('./src/utils/passwordValidation');
-  console.log(validatePassword('Test123!Pass'));
-"
-
-# Check if tables exist
-docker exec wedding-photo-sharing-backend-1 node scripts/add-token-revocation-tables.js
-```
-
-## Next Steps
-
-1. Review `AUTH_V2_DEPLOYMENT_PLAN.md`
-2. Install zxcvbn: `npm install zxcvbn@4.4.2`
-3. Run migrations
-4. Deploy incrementally
-5. Monitor for issues
-
-All critical authentication vulnerabilities have been addressed with production-ready fixes!

backend/Dockerfile

@@ -16,8 +16,8 @@ FROM node:18-alpine
 
 WORKDIR /app
 
-# Install dumb-init for proper signal handling
-RUN apk add --no-cache dumb-init
+# Install dumb-init for proper signal handling and postgresql-client for database checks
+RUN apk add --no-cache dumb-init postgresql-client
 
 # Create non-root user
 RUN addgroup -g 1001 -S nodejs && adduser -S nodejs -u 1001
@@ -26,6 +26,9 @@ RUN addgroup -g 1001 -S nodejs && adduser -S nodejs -u 1001
 COPY --from=builder --chown=nodejs:nodejs /app/node_modules ./node_modules
 COPY --chown=nodejs:nodejs . .
 
+# Make wait script executable
+RUN chmod +x wait-for-db.sh
+
 # Create necessary directories
 RUN mkdir -p storage/events/active storage/events/archived storage/thumbnails data logs && \
     chown -R nodejs:nodejs storage data logs
@@ -35,4 +38,4 @@ USER nodejs
 EXPOSE 3000
 
 ENTRYPOINT ["dumb-init", "--"]
-CMD ["node", "server.js"]
+CMD ["./wait-for-db.sh", "node", "server.js"]

backend/SAFE_AUTH_ACTIVATION_PLAN.md

@@ -1,215 +0,0 @@
-# Safe Authentication Security Activation Plan
-
-## Current Situation Analysis
-
-### ✅ What's Already Protected:
-- **SQL Injection**: Fully protected with parameterized queries
-- **Rate Limiting**: Basic rate limiting active (5 attempts/15 min on /auth)
-- **Password Hashing**: Bcrypt in use
-- **CORS**: Properly configured
-
-### ❌ What's NOT Protected:
-- **No Account Lockout**: After rate limit, users can keep trying
-- **No Audit Trail**: Can't track attack patterns
-- **No Session Invalidation**: Can't force logout
-- **Limited Token Security**: Basic JWT validation only
-
-## Potential Problems & Solutions
-
-### Problem 1: Existing User Sessions
-**Risk**: Users might get logged out unexpectedly
-**Solution**: 
-- Enhanced auth accepts old tokens (backward compatible)
-- Tokens remain valid until natural expiration
-- Only new features (IP check, password change detection) are additions
-
-### Problem 2: Accidental Lockouts
-**Risk**: Legitimate users locked out due to typos
-**Solution**:
-- 5 attempts is reasonable (not too strict)
-- 30-minute lockout (not permanent)
-- Clear lockout message with retry time
-- Admin bypass SQL query ready
-
-### Problem 3: Database Migration Failure
-**Risk**: Schema changes could fail
-**Solution**:
-- Migrations only ADD tables/columns (no modifications)
-- Automatic backup before migration
-- Rollback plan ready
-- SQLite is forgiving with schema changes
-
-### Problem 4: Performance Impact
-**Risk**: Login tracking could slow down auth
-**Solution**:
-- Indexed columns for performance
-- Automatic cleanup of old records
-- Async logging (non-blocking)
-
-## Step-by-Step Activation Plan
-
-### Phase 1: Pre-Flight Checks (NOW)
-```bash
-# Run safety check script
-cd backend
-node scripts/safe-auth-deployment.js
-```
-This will:
-- ✓ Check database health
-- ✓ Count active sessions
-- ✓ Create backup
-- ✓ Test enhanced auth modules
-
-### Phase 2: Database Preparation (SAFE)
-```bash
-# Run in Docker
-docker exec wedding-photo-sharing-backend-1 npx knex migrate:latest
-```
-Creates:
-- `login_attempts` table (new)
-- Security columns in `admin_users` (nullable)
-
-### Phase 3: Test Without Activation
-```bash
-# Test enhanced auth endpoints
-chmod +x scripts/test-auth-deployment.sh
-./scripts/test-auth-deployment.sh
-```
-Verifies enhanced auth works before switching
-
-### Phase 4: Gradual Activation
-
-#### Option A: Canary Deployment (SAFEST)
-Add temporary route to test:
-```javascript
-// In server.js, add both temporarily
-app.use('/api/auth', authRoutes);  // Original
-app.use('/api/auth-new', authEnhancedRoutes);  // Test enhanced
-```
-
-Test with `/api/auth-new/admin/login` first
-
-#### Option B: Feature Flag (RECOMMENDED)
-```javascript
-// In server.js
-const useEnhancedAuth = process.env.USE_ENHANCED_AUTH === 'true';
-const authRoutes = useEnhancedAuth 
-  ? require('./src/routes/auth-enhanced')
-  : require('./src/routes/auth');
-```
-
-Then activate with environment variable
-
-#### Option C: Direct Switch (FASTER)
-```javascript
-// Change in server.js
-const authRoutes = require('./src/routes/auth-enhanced');
-
-// Add after DB init
-const { initializeCleanupJob } = require('./src/utils/authSecurity');
-initializeCleanupJob();
-```
-
-### Phase 5: Monitor After Activation
-```bash
-# Run monitoring script
-node scripts/monitor-auth-health.js
-```
-
-Watch for:
-- Sudden spike in failures
-- Multiple lockouts
-- Low success rate
-
-## Rollback Procedures
-
-### Quick Rollback (< 30 seconds):
-```bash
-# In server.js, revert to:
-const authRoutes = require('./src/routes/auth');
-
-# Restart
-docker-compose restart backend
-```
-
-### Clear All Lockouts:
-```bash
-docker exec wedding-photo-sharing-backend-1 node -e "
-  const {db} = require('./src/database/db');
-  db('login_attempts').where('success', false).delete()
-    .then(() => console.log('Lockouts cleared'))
-    .then(() => db.destroy());
-"
-```
-
-### Emergency Admin Access:
-```sql
--- If admin is locked out
-DELETE FROM login_attempts WHERE identifier = 'admin';
-```
-
-## Success Criteria
-
-After activation, you should see:
-1. ✅ Failed login attempts recorded in database
-2. ✅ Account lockout after 5 failures
-3. ✅ Logout endpoint working
-4. ✅ No increase in auth errors
-5. ✅ Existing users still able to login
-
-## Timeline Recommendation
-
-**Day 1 (Now)**: 
-- Run migrations ✓
-- Deploy code ✓
-- Test endpoints
-
-**Day 2**: 
-- Monitor current auth patterns
-- Run test script during low traffic
-
-**Day 3**: 
-- Activate with feature flag
-- Monitor closely for 2 hours
-- Full activation if stable
-
-**Day 4+**: 
-- Review login_attempts data
-- Adjust thresholds if needed
-- Plan 2FA implementation
-
-## Commands Reference
-
-```bash
-# Activate enhanced auth
-docker exec -it wedding-photo-sharing-backend-1 /bin/sh
-vi server.js  # Make changes
-exit
-docker-compose restart backend
-
-# Monitor
-docker-compose logs -f backend | grep -i auth
-
-# Check lockouts
-docker exec wedding-photo-sharing-backend-1 node -e "
-  const {db} = require('./src/database/db');
-  db('login_attempts')
-    .select('identifier')
-    .where('success', false)
-    .where('attempt_time', '>', new Date(Date.now() - 15*60*1000).toISOString())
-    .groupBy('identifier')
-    .havingRaw('COUNT(*) >= 5')
-    .then(locked => console.log('Locked accounts:', locked))
-    .then(() => db.destroy());
-"
-```
-
-## Final Safety Notes
-
-1. **It's been tested**: 10/10 unit tests pass
-2. **It's backward compatible**: Old tokens work
-3. **It's gradual**: Can activate features separately  
-4. **It's reversible**: Quick rollback available
-5. **It's monitored**: Health checking included
-
-The enhanced auth is designed to be transparent to users while significantly improving security. The only visible change is lockout messages after failed attempts.

backend/SECURITY_FIXES_COMPLETE.md

@@ -1,167 +0,0 @@
-# Security Fixes Deployment Complete ✅
-
-## Current Protection Status
-
-### 🛡️ FULLY PROTECTED Against:
-
-1. **SQL Injection** ✅
-   - All `whereRaw` queries replaced with parameterized queries
-   - LIKE patterns properly escaped
-   - Input validation for all user inputs
-   - **Status**: ACTIVE & PROTECTING
-
-2. **Brute Force Attacks** ✅
-   - Account lockout after 5 failed attempts
-   - 30-minute lockout duration
-   - IP and user agent tracking
-   - **Status**: ACTIVE & PROTECTING
-
-3. **User Enumeration** ✅
-   - Generic error messages for all auth failures
-   - Returns "Invalid credentials" consistently
-   - **Status**: ACTIVE & PROTECTING
-
-4. **Session Security** ✅
-   - Enhanced JWT with issuer validation
-   - IP tracking in tokens
-   - Password change detection
-   - Logout endpoint functional
-   - **Status**: ACTIVE & PROTECTING
-
-5. **Audit Trail** ✅
-   - All login attempts tracked in database
-   - Success/failure logging with timestamps
-   - IP address and user agent recording
-   - **Status**: ACTIVE & LOGGING
-
-## What Was Done
-
-### Database Changes
-- ✅ Created `login_attempts` table for tracking
-- ✅ Added security columns to `admin_users`:
-  - `password_changed_at`
-  - `last_login_ip`
-  - `two_factor_enabled`
-  - `two_factor_secret`
-
-### Code Changes
-- ✅ SQL injection fixes in 3 files
-- ✅ Enhanced auth middleware deployed
-- ✅ Enhanced auth routes active
-- ✅ Security utilities in place
-- ✅ Cleanup job running
-
-### Files Modified/Created
-```
-backend/
-├── src/
-│   ├── utils/
-│   │   ├── sqlSecurity.js ✅
-│   │   └── authSecurity.js ✅
-│   ├── middleware/
-│   │   └── auth-enhanced.js ✅
-│   └── routes/
-│       ├── auth-enhanced.js ✅
-│       ├── adminDashboard.js ✅ (SQL fixes)
-│       ├── adminEvents.js ✅ (SQL fixes)
-│       └── adminPhotos.js ✅ (SQL fixes)
-└── server.js ✅ (using enhanced auth)
-```
-
-## Monitoring Commands
-
-### Check Login Attempts
-```bash
-docker exec wedding-photo-sharing-backend-1 node -e "
-  const {db} = require('./src/database/db');
-  db('login_attempts')
-    .orderBy('attempt_time', 'desc')
-    .limit(10)
-    .then(attempts => {
-      console.log('Recent login attempts:');
-      attempts.forEach(a => {
-        console.log(\`\${a.attempt_time} - \${a.identifier} - \${a.success ? 'SUCCESS' : 'FAILED'}\`);
-      });
-    })
-    .then(() => db.destroy());
-"
-```
-
-### Check Locked Accounts
-```bash
-docker exec wedding-photo-sharing-backend-1 node -e "
-  const {db} = require('./src/database/db');
-  db('login_attempts')
-    .select('identifier')
-    .where('success', false)
-    .where('attempt_time', '>', new Date(Date.now() - 15*60*1000).toISOString())
-    .groupBy('identifier')
-    .havingRaw('COUNT(*) >= 5')
-    .then(locked => console.log('Locked accounts:', locked))
-    .then(() => db.destroy());
-"
-```
-
-### Monitor Health
-```bash
-node scripts/monitor-auth-health.js
-```
-
-## Rollback Plan (If Needed)
-
-### Quick Rollback
-```bash
-# Restore original server.js
-cp server.js.backup.1752359680463 server.js
-
-# Restart
-docker-compose restart backend
-```
-
-### Clear Lockouts
-```bash
-docker exec wedding-photo-sharing-backend-1 node -e "
-  const {db} = require('./src/database/db');
-  db('login_attempts').where('success', false).delete()
-    .then(() => console.log('All lockouts cleared'))
-    .then(() => db.destroy());
-"
-```
-
-## Next Steps
-
-### Immediate
-1. Monitor logs for any auth errors
-2. Watch for excessive lockouts
-3. Review login attempts daily
-
-### Short Term (1-2 weeks)
-1. Analyze login patterns
-2. Adjust lockout thresholds if needed
-3. Set up alerts for suspicious activity
-
-### Long Term
-1. Implement 2FA (columns already added)
-2. Add IP whitelisting for admins
-3. Implement password complexity requirements
-4. Add password expiration policies
-
-## Security Improvements Summary
-
-| Vulnerability | Before | After | Impact |
-|--------------|---------|--------|---------|
-| SQL Injection | ❌ Direct interpolation | ✅ Parameterized queries | Critical fix |
-| Brute Force | ❌ Unlimited attempts | ✅ 5 attempt lockout | High impact |
-| User Enum | ❌ Different errors | ✅ Generic errors | Medium impact |
-| Audit Trail | ❌ No tracking | ✅ Complete logging | High value |
-| Session Mgmt | ❌ Basic JWT | ✅ Enhanced validation | Medium impact |
-
-## Final Notes
-
-- All fixes are backward compatible
-- Existing sessions remain valid
-- No user impact expected
-- Quick rollback available
-- Monitoring in place
-
-The application is now significantly more secure with protection against common attack vectors. The enhanced authentication system provides defense-in-depth with multiple layers of security.

backend/SQL_INJECTION_FIX_MIGRATION.md

@@ -1,158 +0,0 @@
-# SQL Injection Fix Migration Guide
-
-## Overview
-This document describes the SQL injection vulnerability fixes applied to the PicPeak backend and the migration process for deploying these fixes to production.
-
-## Vulnerabilities Fixed
-
-### 1. WhereRaw Date Queries (High Risk)
-**Location**: `adminDashboard.js`
-- **Issue**: Direct string interpolation in SQL date calculations
-- **Example**: `.whereRaw(\`timestamp >= datetime("now", "-${days} days")\`)`
-- **Fix**: Replaced with parameterized queries using ISO date strings
-
-### 2. LIKE Pattern Injection (Medium Risk)
-**Locations**: `adminEvents.js`, `adminPhotos.js`
-- **Issue**: Unescaped user input in LIKE queries
-- **Example**: `.where('event_name', 'like', \`%${search}%\`)`
-- **Fix**: Added proper escaping for LIKE special characters (%, _, \)
-
-### 3. Dynamic Column/Order Injection (Low Risk)
-**Locations**: Various sorting operations
-- **Issue**: Unvalidated column names in ORDER BY
-- **Fix**: Whitelist validation for sort columns and orders
-
-## Files Changed
-
-1. **Created**: `backend/src/utils/sqlSecurity.js`
-   - Central security utility functions
-   - `sanitizeDays()` - Validates numeric input
-   - `escapeLikePattern()` - Escapes LIKE wildcards
-   - `validateSortColumn()` - Whitelist validation
-   - `validateSortOrder()` - Ensures only 'asc' or 'desc'
-
-2. **Modified**: `backend/src/routes/adminDashboard.js`
-   - Lines 21-24, 39-41, 45-47, 57-61, 65-68: Replaced whereRaw with parameterized queries
-   - Line 4: Added security utility imports
-   - Line 198: Added sanitizeDays for analytics
-
-3. **Modified**: `backend/src/routes/adminEvents.js`
-   - Line 11: Added escapeLikePattern import
-   - Lines 156-161: Escaped search patterns in LIKE queries
-
-4. **Modified**: `backend/src/routes/adminPhotos.js`
-   - Line 9: Added escapeLikePattern import
-   - Lines 477-478: Escaped search patterns in LIKE queries
-
-## Migration Steps
-
-### 1. Pre-Deployment Testing
-
-```bash
-# Run security utility tests
-cd backend
-node scripts/test-sql-security.js
-
-# Run verification script
-node scripts/verify-sql-fixes.js
-```
-
-### 2. Development Environment Testing
-
-```bash
-# Start development server
-npm run dev
-
-# Test key endpoints:
-curl http://localhost:3001/api/admin/dashboard/stats -H "Authorization: Bearer YOUR_TOKEN"
-curl http://localhost:3001/api/admin/events?search=test -H "Authorization: Bearer YOUR_TOKEN"
-curl http://localhost:3001/api/admin/dashboard/analytics?days=7 -H "Authorization: Bearer YOUR_TOKEN"
-```
-
-### 3. Production Deployment
-
-#### Option A: Docker Deployment
-```bash
-# Pull latest changes
-git pull
-
-# Rebuild and restart
-docker-compose down
-docker-compose up -d --build
-```
-
-#### Option B: PM2 Deployment
-```bash
-# Pull latest changes
-git pull
-
-# Install dependencies (if any)
-cd backend
-npm install
-
-# Restart with PM2
-pm2 restart picpeak-backend
-```
-
-### 4. Post-Deployment Verification
-
-1. **Monitor Logs**:
-   ```bash
-   # Docker
-   docker-compose logs -f backend
-   
-   # PM2
-   pm2 logs picpeak-backend
-   ```
-
-2. **Test Critical Functions**:
-   - Admin dashboard loads correctly
-   - Event search works with special characters
-   - Analytics charts display properly
-   - Photo search functions normally
-
-3. **Check Error Rates**:
-   - Monitor for any 500 errors
-   - Check database query logs for errors
-
-## Testing Special Characters
-
-After deployment, test these scenarios:
-
-1. **Search with wildcards**: Search for "50%" or "user_name"
-2. **Search with quotes**: Search for "O'Brien"
-3. **Date range**: Change analytics to different day ranges
-4. **Malicious input**: Try "'; DROP TABLE --" (should return no results)
-
-## Rollback Instructions
-
-If issues occur, see `SQL_INJECTION_FIX_ROLLBACK.md` for immediate rollback steps.
-
-## Performance Impact
-
-- Minimal performance impact expected
-- Date calculations now use ISO strings instead of SQLite functions
-- LIKE pattern escaping adds negligible overhead
-- All changes maintain existing query optimization
-
-## Security Improvements
-
-1. **Eliminated SQL Injection Vectors**: No more direct string interpolation
-2. **Input Validation**: All user inputs are validated/sanitized
-3. **Parameterized Queries**: Using Knex's built-in parameterization
-4. **Defense in Depth**: Multiple layers of protection
-
-## Future Recommendations
-
-1. Add request validation middleware
-2. Implement rate limiting on search endpoints
-3. Add SQL query logging for security auditing
-4. Consider using prepared statements for complex queries
-
-## Questions/Support
-
-If you encounter any issues during migration:
-1. Check the rollback plan first
-2. Review error logs for specific issues
-3. Test individual endpoints to isolate problems
-4. Contact development team if needed

backend/SQL_INJECTION_FIX_ROLLBACK.md

@@ -1,94 +0,0 @@
-# SQL Injection Fix Rollback Plan
-
-## Overview
-This document provides a rollback plan in case the SQL injection fixes cause issues in production.
-
-## Changes Made
-1. **Created**: `backend/src/utils/sqlSecurity.js` - Central security utilities
-2. **Modified**: `backend/src/routes/adminDashboard.js` - Replaced whereRaw with parameterized queries
-3. **Modified**: `backend/src/routes/adminPhotos.js` - Added LIKE pattern escaping
-4. **Modified**: `backend/src/routes/adminEvents.js` - Added LIKE pattern escaping
-
-## Quick Rollback Steps
-
-### Step 1: Revert Code Changes
-If issues occur, run these commands to revert:
-
-```bash
-# Navigate to backend directory
-cd backend
-
-# Revert specific files
-git checkout HEAD -- src/routes/adminDashboard.js
-git checkout HEAD -- src/routes/adminPhotos.js
-git checkout HEAD -- src/routes/adminEvents.js
-
-# Remove the new security utility file
-rm src/utils/sqlSecurity.js
-```
-
-### Step 2: Restart Services
-```bash
-# If using Docker
-docker-compose restart backend
-
-# If using PM2
-pm2 restart picpeak-backend
-```
-
-## Verification After Rollback
-
-1. Check admin dashboard loads: `/admin/dashboard`
-2. Test event search functionality
-3. Test photo search functionality
-4. Verify analytics charts display correctly
-
-## Symptoms That May Require Rollback
-
-1. **Dashboard Statistics Not Loading**
-   - Empty or NaN values in stats
-   - Analytics charts not rendering
-
-2. **Search Features Broken**
-   - Event search returns no results
-   - Photo search returns errors
-   - Special characters in search causing issues
-
-3. **Date Filtering Issues**
-   - Activity logs not showing correct date ranges
-   - Analytics showing incorrect time periods
-
-## Safe Testing Before Production
-
-1. **Test in Development First**:
-   ```bash
-   cd backend
-   npm run dev
-   ```
-
-2. **Test Key Features**:
-   - Admin dashboard stats: `http://localhost:3001/api/admin/dashboard/stats`
-   - Analytics: `http://localhost:3001/api/admin/dashboard/analytics?days=7`
-   - Event search: `http://localhost:3001/api/admin/events?search=test`
-   - Photo search: `http://localhost:3001/api/admin/events/1/photos?search=test`
-
-3. **Monitor Logs**:
-   ```bash
-   # Docker logs
-   docker-compose logs -f backend
-
-   # PM2 logs
-   pm2 logs picpeak-backend
-   ```
-
-## Emergency Contacts
-- Keep database backups before deploying
-- Have monitoring alerts for 500 errors
-- Document any custom SQL queries in use
-
-## Post-Rollback Actions
-If rollback is needed:
-1. Document the specific issue encountered
-2. Create test cases for the failure scenario
-3. Fix the issue in development
-4. Re-test thoroughly before re-deploying

backend/SQL_INJECTION_FIX_SUMMARY.md

@@ -1,64 +0,0 @@
-# SQL Injection Fix Summary
-
-## Quick Overview
-Fixed SQL injection vulnerabilities in the admin panel endpoints by:
-1. Replacing dangerous `whereRaw` queries with parameterized queries
-2. Escaping special characters in LIKE patterns
-3. Validating sort columns and orders
-
-## Test Results
-✅ All 31 security tests passed
-✅ Verification script confirms fixes working
-✅ No breaking changes to API functionality
-
-## Changed Files
-```
-backend/
-├── src/
-│   ├── utils/
-│   │   └── sqlSecurity.js (NEW - 117 lines)
-│   └── routes/
-│       ├── adminDashboard.js (6 changes)
-│       ├── adminEvents.js (2 changes)
-│       └── adminPhotos.js (2 changes)
-└── scripts/
-    ├── test-sql-security.js (NEW)
-    └── verify-sql-fixes.js (NEW)
-```
-
-## Before & After Examples
-
-### Date Range Queries
-```javascript
-// ❌ BEFORE (Vulnerable)
-.whereRaw(`timestamp >= datetime("now", "-${days} days")`)
-
-// ✅ AFTER (Safe)
-const startDate = new Date();
-startDate.setDate(startDate.getDate() - sanitizeDays(days));
-.where('timestamp', '>=', startDate.toISOString())
-```
-
-### LIKE Queries
-```javascript
-// ❌ BEFORE (Vulnerable)
-.where('event_name', 'like', `%${search}%`)
-
-// ✅ AFTER (Safe)
-const escapedSearch = escapeLikePattern(search);
-.where('event_name', 'like', `%${escapedSearch}%`)
-```
-
-## Deployment Checklist
-- [ ] Run `node scripts/test-sql-security.js` (should show 31/31 passed)
-- [ ] Test in development environment
-- [ ] Review rollback plan (`SQL_INJECTION_FIX_ROLLBACK.md`)
-- [ ] Deploy to production
-- [ ] Monitor logs for errors
-- [ ] Test search functionality with special characters
-
-## Risk Assessment
-- **Risk Level**: Low (with proper testing)
-- **Breaking Changes**: None
-- **Performance Impact**: Minimal
-- **Rollback Time**: < 2 minutes

backend/audit-backend.json

@@ -0,0 +1,22 @@
+{
+  "auditReportVersion": 2,
+  "vulnerabilities": {},
+  "metadata": {
+    "vulnerabilities": {
+      "info": 0,
+      "low": 0,
+      "moderate": 0,
+      "high": 0,
+      "critical": 0,
+      "total": 0
+    },
+    "dependencies": {
+      "prod": 329,
+      "dev": 307,
+      "optional": 54,
+      "peer": 1,
+      "peerOptional": 0,
+      "total": 690
+    }
+  }
+}

backend/init-production.sh

@@ -0,0 +1,50 @@
+#!/bin/sh
+# init-production.sh - Production initialization script
+
+set -e
+
+echo "🚀 Initializing PicPeak Production Environment..."
+
+# Wait for services to be ready
+echo "⏳ Waiting for database to be fully ready..."
+sleep 3
+
+# Fix permissions if running as root (shouldn't happen with proper Dockerfile)
+if [ "$(id -u)" = "0" ]; then
+    echo "🔧 Fixing file permissions..."
+    chown -R nodejs:nodejs /app/storage /app/data /app/logs 2>/dev/null || true
+fi
+
+# Create required directories
+echo "📁 Creating required directories..."
+mkdir -p /app/storage/events/active \
+         /app/storage/events/archived \
+         /app/storage/thumbnails \
+         /app/storage/uploads/logos \
+         /app/storage/uploads/favicons \
+         /app/data \
+         /app/logs
+
+# Run migrations with safe runner
+echo "🗄️ Running database migrations (safe mode)..."
+NODE_ENV=production npm run migrate:safe
+
+# Create admin user if environment variables are set
+if [ -n "$ADMIN_EMAIL" ] && [ -n "$ADMIN_PASSWORD" ]; then
+    echo "👤 Creating admin user..."
+    node scripts/create-admin.js \
+        --email "$ADMIN_EMAIL" \
+        --username "${ADMIN_USERNAME:-admin}" \
+        --password "$ADMIN_PASSWORD" || echo "Admin user might already exist"
+fi
+
+# Initialize email configuration if variables are set
+if [ -n "$SMTP_HOST" ]; then
+    echo "📧 Email configuration detected via environment variables"
+fi
+
+echo "✅ Production initialization complete!"
+echo "🌐 Starting application server..."
+
+# Start the application
+exec node server.js

backend/knexfile.js

@@ -0,0 +1,59 @@
+require('dotenv').config();
+
+const path = require('path');
+
+// Database configuration for different environments
+const config = {
+  development: {
+    client: process.env.DATABASE_CLIENT || 'sqlite3',
+    connection: process.env.DATABASE_CLIENT === 'pg' ? {
+      host: process.env.DB_HOST || 'localhost',
+      port: process.env.DB_PORT || 5432,
+      user: process.env.DB_USER || 'postgres',
+      password: process.env.DB_PASSWORD || 'postgres',
+      database: process.env.DB_NAME || 'photo_sharing'
+    } : {
+      filename: path.join(__dirname, process.env.DATABASE_PATH || './data/photo_sharing.db')
+    },
+    useNullAsDefault: process.env.DATABASE_CLIENT !== 'pg',
+    migrations: {
+      directory: './migrations'
+    },
+    seeds: {
+      directory: './seeds'
+    }
+  },
+
+  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
+    },
+    migrations: {
+      directory: './migrations'
+    },
+    acquireConnectionTimeout: 60000
+  }
+};
+
+module.exports = config[process.env.NODE_ENV || 'development'];

backend/migrations/018_add_created_at_to_email_queue.js

@@ -0,0 +1,23 @@
+exports.up = async function(knex) {
+  // Check if created_at column already exists
+  const hasCreatedAt = await knex.schema.hasColumn('email_queue', 'created_at');
+  
+  if (!hasCreatedAt) {
+    await knex.schema.table('email_queue', (table) => {
+      table.datetime('created_at').defaultTo(knex.fn.now());
+    });
+    
+    // Update existing rows to have a created_at value based on scheduled_at
+    await knex('email_queue')
+      .whereNull('created_at')
+      .update({
+        created_at: knex.ref('scheduled_at')
+      });
+  }
+};
+
+exports.down = async function(knex) {
+  await knex.schema.table('email_queue', (table) => {
+    table.dropColumn('created_at');
+  });
+};

backend/migrations/019_fix_email_templates_columns.js

@@ -0,0 +1,35 @@
+exports.up = async function(knex) {
+  // Check current column structure
+  const hasSubjectEn = await knex.schema.hasColumn('email_templates', 'subject_en');
+  const hasSubject = await knex.schema.hasColumn('email_templates', 'subject');
+  
+  if (hasSubjectEn && !hasSubject) {
+    // The language migration was applied, need to add back basic columns
+    await knex.schema.alterTable('email_templates', function(table) {
+      table.string('subject');
+      table.text('body_html');
+      table.text('body_text');
+    });
+    
+    // Copy English values to the basic columns
+    await knex('email_templates').update({
+      subject: knex.raw('subject_en'),
+      body_html: knex.raw('body_html_en'),
+      body_text: knex.raw('body_text_en')
+    });
+  }
+};
+
+exports.down = async function(knex) {
+  // Check if we have the basic columns
+  const hasSubject = await knex.schema.hasColumn('email_templates', 'subject');
+  const hasSubjectEn = await knex.schema.hasColumn('email_templates', 'subject_en');
+  
+  if (hasSubject && hasSubjectEn) {
+    await knex.schema.alterTable('email_templates', function(table) {
+      table.dropColumn('subject');
+      table.dropColumn('body_html');
+      table.dropColumn('body_text');
+    });
+  }
+};

backend/migrations/020_ensure_default_email_templates.js

@@ -0,0 +1,91 @@
+exports.up = async function(knex) {
+  // Check if we have the default email templates
+  const templates = await knex('email_templates').select('template_key');
+  const existingKeys = templates.map(t => t.template_key);
+  
+  // Check which columns exist in the table
+  const hasSubjectEn = await knex.schema.hasColumn('email_templates', 'subject_en');
+  const hasSubject = await knex.schema.hasColumn('email_templates', 'subject');
+  
+  // Determine which columns to use based on schema
+  const subjectCol = hasSubjectEn ? 'subject_en' : 'subject';
+  const bodyHtmlCol = hasSubjectEn ? 'body_html_en' : 'body_html';
+  const bodyTextCol = hasSubjectEn ? 'body_text_en' : 'body_text';
+  
+  const defaultTemplates = [
+    {
+      template_key: 'gallery_created',
+      [subjectCol]: 'Your Photo Gallery is Ready!',
+      [bodyHtmlCol]: `<h2>Gallery Created Successfully</h2>
+<p>Dear {{host_name}},</p>
+<p>Your photo gallery "{{event_name}}" has been created successfully!</p>
+<p><strong>Gallery Details:</strong></p>
+<ul>
+  <li>Event Date: {{event_date}}</li>
+  <li>Gallery Link: {{gallery_link}}</li>
+  <li>Password: {{gallery_password}}</li>
+  <li>Expires: {{expiry_date}}</li>
+</ul>
+<p>Share this link and password with your guests to allow them to view and download photos.</p>`,
+      [bodyTextCol]: 'Gallery Created Successfully\n\nDear {{host_name}},\n\nYour photo gallery "{{event_name}}" has been created successfully!',
+      variables: JSON.stringify(['host_name', 'event_name', 'event_date', 'gallery_link', 'gallery_password', 'expiry_date'])
+    },
+    {
+      template_key: 'expiration_warning',
+      [subjectCol]: 'Your Photo Gallery Expires Soon',
+      [bodyHtmlCol]: `<h2>Gallery Expiring Soon</h2>
+<p>Dear {{host_name}},</p>
+<p>Your photo gallery "{{event_name}}" will expire in {{days_remaining}} days.</p>
+<p>After expiration, the gallery will be archived and no longer accessible to guests.</p>
+<p><a href="{{gallery_link}}">Visit Gallery</a></p>`,
+      [bodyTextCol]: 'Gallery Expiring Soon\n\nDear {{host_name}},\n\nYour photo gallery "{{event_name}}" will expire in {{days_remaining}} days.',
+      variables: JSON.stringify(['host_name', 'event_name', 'days_remaining', 'gallery_link'])
+    },
+    {
+      template_key: 'gallery_expired',
+      [subjectCol]: 'Your Photo Gallery Has Expired',
+      [bodyHtmlCol]: `<h2>Gallery Expired</h2>
+<p>Dear {{host_name}},</p>
+<p>Your photo gallery "{{event_name}}" has expired and been archived.</p>
+<p>The photos are safely stored in our archive system. If you need access to the archived photos, please contact support.</p>`,
+      [bodyTextCol]: 'Gallery Expired\n\nDear {{host_name}},\n\nYour photo gallery "{{event_name}}" has expired and been archived.',
+      variables: JSON.stringify(['host_name', 'event_name'])
+    },
+    {
+      template_key: 'archive_complete',
+      [subjectCol]: 'Gallery Archive Complete',
+      [bodyHtmlCol]: `<h2>Archive Complete</h2>
+<p>Dear {{host_name}},</p>
+<p>Your photo gallery "{{event_name}}" has been successfully archived.</p>
+<p>Archive size: {{archive_size}}</p>
+<p>The archive is stored securely and can be retrieved if needed.</p>`,
+      [bodyTextCol]: 'Archive Complete\n\nDear {{host_name}},\n\nYour photo gallery "{{event_name}}" has been successfully archived.',
+      variables: JSON.stringify(['host_name', 'event_name', 'archive_size'])
+    }
+  ];
+  
+  // Insert missing templates
+  for (const template of defaultTemplates) {
+    if (!existingKeys.includes(template.template_key)) {
+      // If we have language columns, also set German versions with same content
+      if (hasSubjectEn) {
+        template.subject_de = template[subjectCol];
+        template.body_html_de = template[bodyHtmlCol];
+        template.body_text_de = template[bodyTextCol];
+        
+        // Also ensure we have the basic columns if they exist
+        if (hasSubject) {
+          template.subject = template[subjectCol];
+          template.body_html = template[bodyHtmlCol];
+          template.body_text = template[bodyTextCol];
+        }
+      }
+      
+      await knex('email_templates').insert(template);
+    }
+  }
+};
+
+exports.down = async function(knex) {
+  // Don't remove templates on rollback as they might have been customized
+};

backend/migrations/021_add_default_cms_pages.js

@@ -0,0 +1,121 @@
+exports.up = async function(knex) {
+  // Check if CMS pages already exist
+  const impressumExists = await knex('cms_pages')
+    .where('slug', 'impressum')
+    .first();
+    
+  const datenschutzExists = await knex('cms_pages')
+    .where('slug', 'datenschutz')
+    .first();
+  
+  const pagesToInsert = [];
+  
+  // Add Impressum page if it doesn't exist
+  if (!impressumExists) {
+    pagesToInsert.push({
+      slug: 'impressum',
+      title_en: 'Legal Notice',
+      title_de: 'Impressum',
+      content_en: `<h1>Legal Notice</h1>
+<p>Information according to § 5 TMG</p>
+
+<h2>Responsible for content</h2>
+<p>[Your Name]<br>
+[Your Address]<br>
+[Postal Code City]</p>
+
+<h2>Contact</h2>
+<p>Email: [Your Email Address]<br>
+Phone: [Your Phone Number]</p>
+
+<h2>Disclaimer</h2>
+<h3>Liability for content</h3>
+<p>The contents of our pages were created with great care. However, we cannot guarantee the accuracy, completeness and timeliness of the content.</p>
+
+<h3>Liability for links</h3>
+<p>Our website contains links to external third-party websites over whose content we have no influence. Therefore, we cannot accept any liability for this third-party content.</p>`,
+      content_de: `<h1>Impressum</h1>
+<p>Angaben gemäß § 5 TMG</p>
+
+<h2>Verantwortlich für den Inhalt</h2>
+<p>[Ihr Name]<br>
+[Ihre Adresse]<br>
+[PLZ Ort]</p>
+
+<h2>Kontakt</h2>
+<p>E-Mail: [Ihre E-Mail-Adresse]<br>
+Telefon: [Ihre Telefonnummer]</p>
+
+<h2>Haftungsausschluss</h2>
+<h3>Haftung für Inhalte</h3>
+<p>Die Inhalte unserer Seiten wurden mit größter Sorgfalt erstellt. Für die Richtigkeit, Vollständigkeit und Aktualität der Inhalte können wir jedoch keine Gewähr übernehmen.</p>
+
+<h3>Haftung für Links</h3>
+<p>Unser Angebot enthält Links zu externen Webseiten Dritter, auf deren Inhalte wir keinen Einfluss haben. Deshalb können wir für diese fremden Inhalte auch keine Gewähr übernehmen.</p>`,
+      updated_at: new Date()
+    });
+  }
+  
+  // Add Datenschutz page if it doesn't exist
+  if (!datenschutzExists) {
+    pagesToInsert.push({
+      slug: 'datenschutz',
+      title_en: 'Privacy Policy',
+      title_de: 'Datenschutzerklärung',
+      content_en: `<h1>Privacy Policy</h1>
+
+<h2>1. Privacy at a Glance</h2>
+<h3>General Information</h3>
+<p>The following information provides a simple overview of what happens to your personal data when you visit this website.</p>
+
+<h3>Data Collection on This Website</h3>
+<p><strong>Who is responsible for data collection on this website?</strong></p>
+<p>Data processing on this website is carried out by the website operator. Their contact details can be found in the legal notice of this website.</p>
+
+<p><strong>How do we collect your data?</strong></p>
+<p>Your data is collected when you provide it to us. This could be data that you enter into a contact form, for example.</p>
+
+<p><strong>What do we use your data for?</strong></p>
+<p>Some of the data is collected to ensure error-free provision of the website. Other data may be used to analyze your user behavior.</p>
+
+<h2>2. Hosting</h2>
+<p>This website is hosted externally. The personal data collected on this website is stored on the servers of the host.</p>
+
+<h2>3. General Information and Mandatory Information</h2>
+<h3>Data Protection</h3>
+<p>The operators of these pages take the protection of your personal data very seriously. We treat your personal data confidentially and in accordance with the statutory data protection regulations and this privacy policy.</p>`,
+      content_de: `<h1>Datenschutzerklärung</h1>
+
+<h2>1. Datenschutz auf einen Blick</h2>
+<h3>Allgemeine Hinweise</h3>
+<p>Die folgenden Hinweise geben einen einfachen Überblick darüber, was mit Ihren personenbezogenen Daten passiert, wenn Sie diese Website besuchen.</p>
+
+<h3>Datenerfassung auf dieser Website</h3>
+<p><strong>Wer ist verantwortlich für die Datenerfassung auf dieser Website?</strong></p>
+<p>Die Datenverarbeitung auf dieser Website erfolgt durch den Websitebetreiber. Dessen Kontaktdaten können Sie dem Impressum dieser Website entnehmen.</p>
+
+<p><strong>Wie erfassen wir Ihre Daten?</strong></p>
+<p>Ihre Daten werden zum einen dadurch erhoben, dass Sie uns diese mitteilen. Hierbei kann es sich z.B. um Daten handeln, die Sie in ein Kontaktformular eingeben.</p>
+
+<p><strong>Wofür nutzen wir Ihre Daten?</strong></p>
+<p>Ein Teil der Daten wird erhoben, um eine fehlerfreie Bereitstellung der Website zu gewährleisten. Andere Daten können zur Analyse Ihres Nutzerverhaltens verwendet werden.</p>
+
+<h2>2. Hosting</h2>
+<p>Diese Website wird extern gehostet. Die personenbezogenen Daten, die auf dieser Website erfasst werden, werden auf den Servern des Hosters gespeichert.</p>
+
+<h2>3. Allgemeine Hinweise und Pflichtinformationen</h2>
+<h3>Datenschutz</h3>
+<p>Die Betreiber dieser Seiten nehmen den Schutz Ihrer persönlichen Daten sehr ernst. Wir behandeln Ihre personenbezogenen Daten vertraulich und entsprechend der gesetzlichen Datenschutzvorschriften sowie dieser Datenschutzerklärung.</p>`,
+      updated_at: new Date()
+    });
+  }
+  
+  // Insert pages if any need to be added
+  if (pagesToInsert.length > 0) {
+    await knex('cms_pages').insert(pagesToInsert);
+  }
+};
+
+exports.down = async function(knex) {
+  // Don't remove CMS pages on rollback as they might have been customized
+};

backend/migrations/022_fix_json_columns.js

@@ -0,0 +1,68 @@
+exports.up = async function(knex) {
+  console.log('Fixing JSON columns in database...');
+  
+  // Fix email_templates variables column
+  const templates = await knex('email_templates').select('id', 'template_key', 'variables');
+  
+  for (const template of templates) {
+    if (template.variables && typeof template.variables === 'string') {
+      try {
+        // Check if it's already valid JSON
+        JSON.parse(template.variables);
+      } catch (e) {
+        console.log(`Fixing invalid JSON in email template ${template.template_key}`);
+        // Attempt to fix common issues
+        let fixed = template.variables;
+        
+        // If it looks like an array but isn't valid JSON, try to fix it
+        if (fixed.startsWith('[') && fixed.endsWith(']')) {
+          // Extract the content and properly format it
+          const content = fixed.slice(1, -1);
+          const items = content.split(',').map(item => item.trim().replace(/['"]/g, ''));
+          fixed = JSON.stringify(items);
+        } else {
+          // Default to empty array if we can't fix it
+          fixed = JSON.stringify([]);
+        }
+        
+        await knex('email_templates')
+          .where('id', template.id)
+          .update({ variables: fixed });
+      }
+    } else if (!template.variables) {
+      // Set default empty array for null values
+      await knex('email_templates')
+        .where('id', template.id)
+        .update({ variables: JSON.stringify([]) });
+    }
+  }
+  
+  // Fix activity_logs metadata column
+  const activities = await knex('activity_logs').select('id', 'metadata');
+  
+  for (const activity of activities) {
+    if (activity.metadata && typeof activity.metadata === 'string') {
+      try {
+        // Check if it's already valid JSON
+        JSON.parse(activity.metadata);
+      } catch (e) {
+        console.log(`Fixing invalid JSON in activity log ${activity.id}`);
+        // Default to empty object if we can't parse it
+        await knex('activity_logs')
+          .where('id', activity.id)
+          .update({ metadata: JSON.stringify({}) });
+      }
+    } else if (!activity.metadata) {
+      // Set default empty object for null values
+      await knex('activity_logs')
+        .where('id', activity.id)
+        .update({ metadata: JSON.stringify({}) });
+    }
+  }
+  
+  console.log('JSON columns fixed successfully');
+};
+
+exports.down = async function(knex) {
+  // No rollback needed - data fixes only
+};

backend/migrations/023_ensure_postgres_compatibility.js

@@ -0,0 +1,22 @@
+/**
+ * Ensure PostgreSQL compatibility for all insert operations
+ * This migration doesn't change the schema but ensures all tables
+ * are compatible with .returning() syntax
+ */
+
+exports.up = async function(knex) {
+  // This migration is informational only
+  // All insert operations should use .returning('id') going forward
+  
+  console.log('PostgreSQL compatibility check:');
+  console.log('- All INSERT operations should use .returning("id")');
+  console.log('- All date operations should use ISO strings');
+  console.log('- Boolean values are handled automatically by Knex');
+  
+  return Promise.resolve();
+};
+
+exports.down = async function(knex) {
+  // No rollback needed
+  return Promise.resolve();
+};

backend/migrations/024_fix_boolean_compatibility.js

@@ -0,0 +1,29 @@
+/**
+ * Fix boolean compatibility issues between PostgreSQL and SQLite
+ * This migration updates the database configuration and existing data
+ */
+
+exports.up = async function(knex) {
+  const isPostgres = knex.client.config.client === 'pg';
+  
+  if (!isPostgres) {
+    // Enable foreign keys for SQLite
+    await knex.raw('PRAGMA foreign_keys = ON');
+    
+    // Note: SQLite stores booleans as 0/1
+    // No data migration needed as Knex handles this automatically
+    // But queries must use formatBoolean() helper
+    
+    console.log('SQLite boolean compatibility check:');
+    console.log('- SQLite stores booleans as 0/1');
+    console.log('- All boolean comparisons should use formatBoolean() helper');
+    console.log('- Foreign keys enabled');
+  }
+  
+  return Promise.resolve();
+};
+
+exports.down = async function(knex) {
+  // No rollback needed
+  return Promise.resolve();
+};

backend/migrations/add_must_change_password.js.old

@@ -1,25 +0,0 @@
-const { db } = require('../src/database/db');
-
-async function addMustChangePasswordColumn() {
-  try {
-    // Check if the column already exists
-    const hasMustChangePassword = await db.schema.hasColumn('admin_users', 'must_change_password');
-    
-    if (!hasMustChangePassword) {
-      await db.schema.table('admin_users', (table) => {
-        table.boolean('must_change_password').defaultTo(false);
-      });
-      
-      console.log('✅ Added must_change_password column to admin_users table');
-    } else {
-      console.log('ℹ️  must_change_password column already exists');
-    }
-    
-    process.exit(0);
-  } catch (error) {
-    console.error('❌ Migration failed:', error);
-    process.exit(1);
-  }
-}
-
-addMustChangePasswordColumn();

backend/migrations/helpers.js

@@ -0,0 +1,83 @@
+/**
+ * Migration helper functions for production-safe migrations
+ */
+
+/**
+ * Create a table only if it doesn't already exist
+ */
+async function createTableIfNotExists(knex, tableName, callback) {
+  const exists = await knex.schema.hasTable(tableName);
+  if (!exists) {
+    console.log(`Creating table: ${tableName}`);
+    return knex.schema.createTable(tableName, callback);
+  } else {
+    console.log(`Table ${tableName} already exists, skipping...`);
+  }
+}
+
+/**
+ * Add column to table only if it doesn't exist
+ */
+async function addColumnIfNotExists(knex, tableName, columnName, callback) {
+  const hasColumn = await knex.schema.hasColumn(tableName, columnName);
+  if (!hasColumn) {
+    console.log(`Adding column ${columnName} to table ${tableName}`);
+    return knex.schema.alterTable(tableName, (table) => {
+      callback(table);
+    });
+  } else {
+    console.log(`Column ${columnName} already exists in table ${tableName}, skipping...`);
+  }
+}
+
+/**
+ * Insert data only if it doesn't already exist
+ */
+async function insertIfNotExists(knex, tableName, data, uniqueField) {
+  const exists = await knex(tableName)
+    .where(uniqueField, data[uniqueField])
+    .first();
+  
+  if (!exists) {
+    console.log(`Inserting ${uniqueField}: ${data[uniqueField]} into ${tableName}`);
+    return knex(tableName).insert(data);
+  } else {
+    console.log(`${uniqueField}: ${data[uniqueField]} already exists in ${tableName}, skipping...`);
+  }
+}
+
+/**
+ * Create index only if it doesn't exist
+ */
+async function createIndexIfNotExists(knex, tableName, columns, indexName) {
+  // This is database-specific, works for PostgreSQL
+  if (knex.client.config.client === 'pg') {
+    const result = await knex.raw(`
+      SELECT 1 FROM pg_indexes 
+      WHERE tablename = ? AND indexname = ?
+    `, [tableName, indexName]);
+    
+    if (result.rows.length === 0) {
+      console.log(`Creating index ${indexName} on ${tableName}`);
+      return knex.schema.alterTable(tableName, (table) => {
+        table.index(columns, indexName);
+      });
+    }
+  } else {
+    // For SQLite, just try to create and ignore errors
+    try {
+      await knex.schema.alterTable(tableName, (table) => {
+        table.index(columns, indexName);
+      });
+    } catch (error) {
+      // Index probably already exists
+    }
+  }
+}
+
+module.exports = {
+  createTableIfNotExists,
+  addColumnIfNotExists,
+  insertIfNotExists,
+  createIndexIfNotExists
+};

backend/migrations/run-migrations-safe.js

@@ -0,0 +1,170 @@
+const fs = require('fs').promises;
+const path = require('path');
+const { db } = require('../src/database/db');
+
+/**
+ * Production-safe migration runner that handles existing schema
+ */
+
+// Create or verify migrations tracking table
+async function ensureMigrationsTable() {
+  const tableExists = await db.schema.hasTable('migrations');
+  if (!tableExists) {
+    await db.schema.createTable('migrations', (table) => {
+      table.increments('id').primary();
+      table.string('filename').unique().notNullable();
+      table.timestamp('applied_at').defaultTo(db.fn.now());
+    });
+    console.log('Created migrations tracking table');
+  }
+}
+
+// Check if a migration has been applied
+async function isMigrationApplied(filename) {
+  const result = await db('migrations').where('filename', filename).first();
+  return !!result;
+}
+
+// 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`);
+}
+
+// Detect existing schema and mark migrations as applied
+async function detectExistingSchema() {
+  console.log('Detecting existing schema...');
+  
+  const tableChecks = [
+    { table: 'events', migration: 'init.js' },
+    { table: 'photos', migration: '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' },
+  ];
+  
+  for (const check of tableChecks) {
+    const exists = await db.schema.hasTable(check.table);
+    if (exists) {
+      const isApplied = await isMigrationApplied(check.migration);
+      if (!isApplied) {
+        await markMigrationAsApplied(check.migration);
+      }
+    }
+  }
+}
+
+// Run a single migration safely
+async function runMigrationSafely(filename) {
+  try {
+    const migrationPath = path.join(__dirname, filename);
+    const migration = require(migrationPath);
+    
+    if (migration.up) {
+      console.log(`Running migration: ${filename}`);
+      
+      // Run migration in a transaction if possible
+      if (db.client.config.client === 'pg') {
+        await db.transaction(async (trx) => {
+          await migration.up(trx);
+        });
+      } else {
+        await migration.up(db);
+      }
+      
+      await db('migrations').insert({ filename });
+      console.log(`Migration ${filename} 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);
+    } else {
+      throw error;
+    }
+  }
+}
+
+// Main migration runner
+async function runMigrations() {
+  let connection;
+  try {
+    console.log('Starting production-safe database migrations...');
+    
+    // Ensure database connection is ready
+    await db.raw('SELECT 1');
+    console.log('Database connection verified');
+    
+    // Create migrations tracking table
+    await ensureMigrationsTable();
+    
+    // Detect and mark existing schema
+    await detectExistingSchema();
+    
+    // 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);
+      });
+    
+    // Run pending migrations
+    let pendingCount = 0;
+    let skippedCount = 0;
+    
+    for (const file of migrationFiles) {
+      const isApplied = await isMigrationApplied(file);
+      if (!isApplied) {
+        await runMigrationSafely(file);
+        pendingCount++;
+      } else {
+        skippedCount++;
+      }
+    }
+    
+    console.log(`\nMigration Summary:`);
+    console.log(`- Applied: ${pendingCount} migration(s)`);
+    console.log(`- Skipped: ${skippedCount} migration(s) (already applied)`);
+    console.log(`- Total: ${migrationFiles.length} migration(s)`);
+    console.log('\nAll migrations completed successfully');
+    
+    // Close database connection
+    await db.destroy();
+    process.exit(0);
+  } catch (error) {
+    console.error('\n❌ Migration failed:', error.message);
+    console.error('Error details:', error);
+    
+    // Close database connection on error
+    try {
+      await db.destroy();
+    } catch (e) {
+      // Ignore
+    }
+    
+    process.exit(1);
+  }
+}
+
+// Add delay for database readiness in production
+async function waitAndRun() {
+  if (process.env.NODE_ENV === 'production') {
+    console.log('Waiting 2 seconds for database readiness...');
+    await new Promise(resolve => setTimeout(resolve, 2000));
+  }
+  await runMigrations();
+}
+
+// Only run if called directly
+if (require.main === module) {
+  waitAndRun();
+}
+
+module.exports = { runMigrations };

backend/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "picpeak-backend",
-  "version": "1.0.2",
+  "version": "1.0.28",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "picpeak-backend",
-      "version": "1.0.2",
+      "version": "1.0.28",
       "dependencies": {
         "adm-zip": "^0.5.16",
         "archiver": "^5.3.1",
@@ -29,6 +29,7 @@
         "multer": "^2.0.1",
         "node-cron": "^3.0.2",
         "nodemailer": "^6.9.1",
+        "pg": "^8.16.3",
         "react-i18next": "^15.6.0",
         "sharp": "^0.32.0",
         "sqlite3": "^5.1.6",
@@ -6471,12 +6472,101 @@
       "integrity": "sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ==",
       "license": "MIT"
     },
+    "node_modules/pg": {
+      "version": "8.16.3",
+      "resolved": "https://registry.npmjs.org/pg/-/pg-8.16.3.tgz",
+      "integrity": "sha512-enxc1h0jA/aq5oSDMvqyW3q89ra6XIIDZgCX9vkMrnz5DFTw/Ny3Li2lFQ+pt3L6MCgm/5o2o8HW9hiJji+xvw==",
+      "license": "MIT",
+      "dependencies": {
+        "pg-connection-string": "^2.9.1",
+        "pg-pool": "^3.10.1",
+        "pg-protocol": "^1.10.3",
+        "pg-types": "2.2.0",
+        "pgpass": "1.0.5"
+      },
+      "engines": {
+        "node": ">= 16.0.0"
+      },
+      "optionalDependencies": {
+        "pg-cloudflare": "^1.2.7"
+      },
+      "peerDependencies": {
+        "pg-native": ">=3.0.1"
+      },
+      "peerDependenciesMeta": {
+        "pg-native": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/pg-cloudflare": {
+      "version": "1.2.7",
+      "resolved": "https://registry.npmjs.org/pg-cloudflare/-/pg-cloudflare-1.2.7.tgz",
+      "integrity": "sha512-YgCtzMH0ptvZJslLM1ffsY4EuGaU0cx4XSdXLRFae8bPP4dS5xL1tNB3k2o/N64cHJpwU7dxKli/nZ2lUa5fLg==",
+      "license": "MIT",
+      "optional": true
+    },
     "node_modules/pg-connection-string": {
       "version": "2.6.1",
       "resolved": "https://registry.npmjs.org/pg-connection-string/-/pg-connection-string-2.6.1.tgz",
       "integrity": "sha512-w6ZzNu6oMmIzEAYVw+RLK0+nqHPt8K3ZnknKi+g48Ak2pr3dtljJW3o+D/n2zzCG07Zoe9VOX3aiKpj+BN0pjg==",
       "license": "MIT"
     },
+    "node_modules/pg-int8": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/pg-int8/-/pg-int8-1.0.1.tgz",
+      "integrity": "sha512-WCtabS6t3c8SkpDBUlb1kjOs7l66xsGdKpIPZsg4wR+B3+u9UAum2odSsF9tnvxg80h4ZxLWMy4pRjOsFIqQpw==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=4.0.0"
+      }
+    },
+    "node_modules/pg-pool": {
+      "version": "3.10.1",
+      "resolved": "https://registry.npmjs.org/pg-pool/-/pg-pool-3.10.1.tgz",
+      "integrity": "sha512-Tu8jMlcX+9d8+QVzKIvM/uJtp07PKr82IUOYEphaWcoBhIYkoHpLXN3qO59nAI11ripznDsEzEv8nUxBVWajGg==",
+      "license": "MIT",
+      "peerDependencies": {
+        "pg": ">=8.0"
+      }
+    },
+    "node_modules/pg-protocol": {
+      "version": "1.10.3",
+      "resolved": "https://registry.npmjs.org/pg-protocol/-/pg-protocol-1.10.3.tgz",
+      "integrity": "sha512-6DIBgBQaTKDJyxnXaLiLR8wBpQQcGWuAESkRBX/t6OwA8YsqP+iVSiond2EDy6Y/dsGk8rh/jtax3js5NeV7JQ==",
+      "license": "MIT"
+    },
+    "node_modules/pg-types": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/pg-types/-/pg-types-2.2.0.tgz",
+      "integrity": "sha512-qTAAlrEsl8s4OiEQY69wDvcMIdQN6wdz5ojQiOy6YRMuynxenON0O5oCpJI6lshc6scgAY8qvJ2On/p+CXY0GA==",
+      "license": "MIT",
+      "dependencies": {
+        "pg-int8": "1.0.1",
+        "postgres-array": "~2.0.0",
+        "postgres-bytea": "~1.0.0",
+        "postgres-date": "~1.0.4",
+        "postgres-interval": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/pg/node_modules/pg-connection-string": {
+      "version": "2.9.1",
+      "resolved": "https://registry.npmjs.org/pg-connection-string/-/pg-connection-string-2.9.1.tgz",
+      "integrity": "sha512-nkc6NpDcvPVpZXxrreI/FOtX3XemeLl8E0qFr6F2Lrm/I8WOnaWNhIPK2Z7OHpw7gh5XJThi6j6ppgNoaT1w4w==",
+      "license": "MIT"
+    },
+    "node_modules/pgpass": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/pgpass/-/pgpass-1.0.5.tgz",
+      "integrity": "sha512-FdW9r/jQZhSeohs1Z3sI1yxFQNFvMcnmfuj4WBMUTxOrAyLMaTcE1aAMBiTlbMNaXvBCQuVi0R7hd8udDSP7ug==",
+      "license": "MIT",
+      "dependencies": {
+        "split2": "^4.1.0"
+      }
+    },
     "node_modules/picocolors": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
@@ -6575,6 +6665,45 @@
         "node": ">=8"
       }
     },
+    "node_modules/postgres-array": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/postgres-array/-/postgres-array-2.0.0.tgz",
+      "integrity": "sha512-VpZrUqU5A69eQyW2c5CA1jtLecCsN2U/bD6VilrFDWq5+5UIEVO7nazS3TEcHf1zuPYO/sqGvUvW62g86RXZuA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/postgres-bytea": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/postgres-bytea/-/postgres-bytea-1.0.0.tgz",
+      "integrity": "sha512-xy3pmLuQqRBZBXDULy7KbaitYqLcmxigw14Q5sj8QBVLqEwXfeybIKVWiqAXTlcvdvb0+xkOtDbfQMOf4lST1w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/postgres-date": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/postgres-date/-/postgres-date-1.0.7.tgz",
+      "integrity": "sha512-suDmjLVQg78nMK2UZ454hAG+OAW+HQPZ6n++TNDUX+L0+uUlLywnoxJKDou51Zm+zTCjrCl0Nq6J9C5hP9vK/Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/postgres-interval": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/postgres-interval/-/postgres-interval-1.2.0.tgz",
+      "integrity": "sha512-9ZhXKM/rw350N1ovuWHbGxnGh/SNJ4cnxHiM0rxE4VN41wsg8P8zWn9hv/buK00RP4WvlOyr/RBDiptyxVbkZQ==",
+      "license": "MIT",
+      "dependencies": {
+        "xtend": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/prebuild-install": {
       "version": "7.1.3",
       "resolved": "https://registry.npmjs.org/prebuild-install/-/prebuild-install-7.1.3.tgz",
@@ -7494,6 +7623,15 @@
         "source-map": "^0.6.0"
       }
     },
+    "node_modules/split2": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/split2/-/split2-4.2.0.tgz",
+      "integrity": "sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==",
+      "license": "ISC",
+      "engines": {
+        "node": ">= 10.x"
+      }
+    },
     "node_modules/sprintf-js": {
       "version": "1.1.3",
       "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.1.3.tgz",

backend/package.json

@@ -1,12 +1,13 @@
 {
   "name": "picpeak-backend",
-  "version": "1.0.2",
+  "version": "1.0.28",
   "description": "Backend for PicPeak event photo sharing platform",
   "main": "server.js",
   "scripts": {
     "start": "node server.js",
     "dev": "nodemon server.js",
     "migrate": "node migrations/run-migrations.js",
+    "migrate:safe": "node migrations/run-migrations-safe.js",
     "test": "jest",
     "lint": "eslint src/"
   },
@@ -32,6 +33,7 @@
     "multer": "^2.0.1",
     "node-cron": "^3.0.2",
     "nodemailer": "^6.9.1",
+    "pg": "^8.16.3",
     "react-i18next": "^15.6.0",
     "sharp": "^0.32.0",
     "sqlite3": "^5.1.6",

backend/scripts/activate-enhanced-auth.js

@@ -1,80 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Activate enhanced authentication in server.js
- * This script safely updates the server configuration
- */
-
-const fs = require('fs').promises;
-const path = require('path');
-
-async function activateEnhancedAuth() {
-  console.log('=== Activating Enhanced Authentication ===\n');
-  
-  try {
-    const serverPath = path.join(__dirname, '../server.js');
-    
-    // Read current server.js
-    let serverContent = await fs.readFile(serverPath, 'utf8');
-    
-    // Backup current server.js
-    const backupPath = `${serverPath}.backup.${Date.now()}`;
-    await fs.writeFile(backupPath, serverContent);
-    console.log(`✓ Created backup: ${path.basename(backupPath)}`);
-    
-    // Check current state
-    if (serverContent.includes("require('./src/routes/auth-enhanced')")) {
-      console.log('! Enhanced auth already active');
-      return;
-    }
-    
-    // Replace auth routes import
-    const originalLine = "const authRoutes = require('./src/routes/auth');";
-    const enhancedLine = "const authRoutes = require('./src/routes/auth-enhanced');";
-    
-    if (!serverContent.includes(originalLine)) {
-      console.log('✗ Could not find original auth import line');
-      console.log('Please manually update server.js');
-      return;
-    }
-    
-    serverContent = serverContent.replace(originalLine, enhancedLine);
-    console.log('✓ Updated auth routes import');
-    
-    // Add cleanup job initialization after database init
-    const dbInitLine = 'initializeDatabase()';
-    const cleanupAddition = `
-  // Initialize auth security cleanup job
-  const { initializeCleanupJob } = require('./src/utils/authSecurity');
-  initializeCleanupJob();
-`;
-    
-    if (!serverContent.includes('initializeCleanupJob')) {
-      const dbInitIndex = serverContent.indexOf(dbInitLine);
-      if (dbInitIndex !== -1) {
-        const insertPoint = serverContent.indexOf('\n', dbInitIndex) + 1;
-        serverContent = serverContent.slice(0, insertPoint) + cleanupAddition + serverContent.slice(insertPoint);
-        console.log('✓ Added cleanup job initialization');
-      }
-    }
-    
-    // Write updated server.js
-    await fs.writeFile(serverPath, serverContent);
-    console.log('✓ Updated server.js');
-    
-    console.log('\n✅ Enhanced authentication activated!');
-    console.log('\nNext steps:');
-    console.log('1. Restart the backend:');
-    console.log('   docker-compose restart backend');
-    console.log('\n2. Monitor auth health:');
-    console.log('   node scripts/monitor-auth-health.js');
-    console.log('\n3. To rollback if needed:');
-    console.log(`   cp ${path.basename(backupPath)} server.js`);
-    console.log('   docker-compose restart backend');
-    
-  } catch (error) {
-    console.error('❌ Error activating enhanced auth:', error);
-  }
-}
-
-activateEnhancedAuth();

backend/scripts/add-auth-tables.js

@@ -1,94 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Add authentication security tables to existing database
- */
-
-const { db } = require('../src/database/db');
-
-async function addAuthTables() {
-  console.log('Adding authentication security tables...\n');
-  
-  try {
-    // 1. Create login_attempts table
-    const hasLoginAttempts = await db.schema.hasTable('login_attempts');
-    if (!hasLoginAttempts) {
-      await db.schema.createTable('login_attempts', table => {
-        table.increments('id').primary();
-        table.string('identifier').notNullable();
-        table.string('ip_address', 45).notNullable();
-        table.text('user_agent');
-        table.timestamp('attempt_time').defaultTo(db.fn.now());
-        table.boolean('success').defaultTo(false);
-        
-        // Indexes for performance
-        table.index('identifier');
-        table.index('attempt_time');
-        table.index(['identifier', 'success', 'attempt_time']);
-      });
-      console.log('✓ Created login_attempts table');
-    } else {
-      console.log('! login_attempts table already exists');
-    }
-    
-    // 2. Add columns to admin_users
-    const hasPasswordChangedAt = await db.schema.hasColumn('admin_users', 'password_changed_at');
-    if (!hasPasswordChangedAt) {
-      await db.schema.table('admin_users', table => {
-        table.timestamp('password_changed_at').nullable();
-      });
-      console.log('✓ Added password_changed_at column');
-    }
-    
-    const hasLastLoginIp = await db.schema.hasColumn('admin_users', 'last_login_ip');
-    if (!hasLastLoginIp) {
-      await db.schema.table('admin_users', table => {
-        table.string('last_login_ip', 45).nullable();
-      });
-      console.log('✓ Added last_login_ip column');
-    }
-    
-    const hasTwoFactorEnabled = await db.schema.hasColumn('admin_users', 'two_factor_enabled');
-    if (!hasTwoFactorEnabled) {
-      await db.schema.table('admin_users', table => {
-        table.boolean('two_factor_enabled').defaultTo(false);
-      });
-      console.log('✓ Added two_factor_enabled column');
-    }
-    
-    const hasTwoFactorSecret = await db.schema.hasColumn('admin_users', 'two_factor_secret');
-    if (!hasTwoFactorSecret) {
-      await db.schema.table('admin_users', table => {
-        table.string('two_factor_secret').nullable();
-      });
-      console.log('✓ Added two_factor_secret column');
-    }
-    
-    // 3. Verify everything
-    console.log('\nVerifying tables...');
-    
-    const loginAttemptsInfo = await db('login_attempts').columnInfo();
-    console.log('✓ login_attempts columns:', Object.keys(loginAttemptsInfo).join(', '));
-    
-    const adminUsersInfo = await db('admin_users').columnInfo();
-    const securityColumns = ['password_changed_at', 'last_login_ip', 'two_factor_enabled', 'two_factor_secret'];
-    const hasAllColumns = securityColumns.every(col => adminUsersInfo[col]);
-    
-    if (hasAllColumns) {
-      console.log('✓ All security columns present in admin_users');
-    } else {
-      console.log('✗ Some security columns missing from admin_users');
-    }
-    
-    console.log('\n✅ Authentication security tables ready!');
-    
-    await db.destroy();
-    process.exit(0);
-  } catch (error) {
-    console.error('\n❌ Error adding auth tables:', error);
-    await db.destroy();
-    process.exit(1);
-  }
-}
-
-addAuthTables();

backend/scripts/add-token-revocation-tables.js

@@ -1,71 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Add token revocation tables to existing database
- */
-
-const { db } = require('../src/database/db');
-
-async function addTokenRevocationTables() {
-  console.log('Adding token revocation tables...\n');
-  
-  try {
-    // 1. Create revoked_tokens table
-    const hasRevokedTokens = await db.schema.hasTable('revoked_tokens');
-    if (!hasRevokedTokens) {
-      await db.schema.createTable('revoked_tokens', table => {
-        table.increments('id').primary();
-        table.string('token_id').notNullable().unique();
-        table.integer('user_id').nullable();
-        table.string('token_type', 20);
-        table.timestamp('revoked_at').defaultTo(db.fn.now());
-        table.timestamp('expires_at').notNullable();
-        table.string('reason', 100);
-        table.text('metadata');
-        
-        // Indexes
-        table.index('token_id');
-        table.index('user_id');
-        table.index('expires_at');
-      });
-      console.log('✓ Created revoked_tokens table');
-    } else {
-      console.log('! revoked_tokens table already exists');
-    }
-    
-    // 2. Create user_token_revocations table
-    const hasUserRevocations = await db.schema.hasTable('user_token_revocations');
-    if (!hasUserRevocations) {
-      await db.schema.createTable('user_token_revocations', table => {
-        table.integer('user_id').primary();
-        table.timestamp('revoked_at').notNullable();
-        table.string('reason', 100);
-        
-        table.index('revoked_at');
-      });
-      console.log('✓ Created user_token_revocations table');
-    } else {
-      console.log('! user_token_revocations table already exists');
-    }
-    
-    // 3. Verify tables
-    console.log('\nVerifying tables...');
-    
-    const revokedTokensInfo = await db('revoked_tokens').columnInfo();
-    console.log('✓ revoked_tokens columns:', Object.keys(revokedTokensInfo).join(', '));
-    
-    const userRevocationsInfo = await db('user_token_revocations').columnInfo();
-    console.log('✓ user_token_revocations columns:', Object.keys(userRevocationsInfo).join(', '));
-    
-    console.log('\n✅ Token revocation tables ready!');
-    
-    await db.destroy();
-    process.exit(0);
-  } catch (error) {
-    console.error('\n❌ Error adding token revocation tables:', error);
-    await db.destroy();
-    process.exit(1);
-  }
-}
-
-addTokenRevocationTables();

backend/scripts/check-db-issues.js

@@ -0,0 +1,60 @@
+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-docker-status.js

@@ -1,96 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Check Docker deployment status for security fixes
- */
-
-console.log('=== Docker Deployment Status Check ===\n');
-
-// Color codes
-const GREEN = '\x1b[32m';
-const RED = '\x1b[31m';
-const YELLOW = '\x1b[33m';
-const RESET = '\x1b[0m';
-
-let allGood = true;
-
-// Check SQL Security
-console.log('1. SQL Injection Fixes:');
-try {
-  const { sanitizeDays, escapeLikePattern } = require('../src/utils/sqlSecurity');
-  console.log(`${GREEN}✓${RESET} sqlSecurity.js exists`);
-  console.log(`${GREEN}✓${RESET} Security functions available`);
-} catch (e) {
-  console.log(`${RED}✗${RESET} sqlSecurity.js missing`);
-  allGood = false;
-}
-
-// Check Auth Security
-console.log('\n2. Authentication Security:');
-try {
-  const authSec = require('../src/utils/authSecurity');
-  console.log(`${GREEN}✓${RESET} authSecurity.js exists`);
-  
-  const authEnhanced = require('../src/middleware/auth-enhanced');
-  console.log(`${GREEN}✓${RESET} auth-enhanced middleware exists`);
-  
-  const authRoutes = require('../src/routes/auth-enhanced');
-  console.log(`${GREEN}✓${RESET} auth-enhanced routes exist`);
-} catch (e) {
-  console.log(`${YELLOW}!${RESET} Auth security files exist but not active`);
-}
-
-// Check Database
-console.log('\n3. Database Status:');
-const { db } = require('../src/database/db');
-
-async function checkDatabase() {
-  try {
-    // Check login_attempts table
-    await db('login_attempts').count();
-    console.log(`${GREEN}✓${RESET} login_attempts table exists`);
-  } catch (e) {
-    console.log(`${YELLOW}!${RESET} login_attempts table not created (run migrations)`);
-  }
-  
-  try {
-    // Check admin_users columns
-    await db('admin_users').select('password_changed_at').limit(1);
-    console.log(`${GREEN}✓${RESET} Auth security columns exist`);
-  } catch (e) {
-    console.log(`${YELLOW}!${RESET} Auth security columns missing (run migrations)`);
-  }
-  
-  // Close database connection
-  await db.destroy();
-}
-
-// Check server configuration
-console.log('\n4. Server Configuration:');
-const fs = require('fs');
-const serverContent = fs.readFileSync('./server.js', 'utf8');
-
-if (serverContent.includes("require('./src/routes/auth-enhanced')")) {
-  console.log(`${GREEN}✓${RESET} Using enhanced auth routes`);
-} else if (serverContent.includes("require('./src/routes/auth')")) {
-  console.log(`${YELLOW}!${RESET} Using original auth routes (enhanced not active)`);
-}
-
-if (serverContent.includes('initializeCleanupJob')) {
-  console.log(`${GREEN}✓${RESET} Auth cleanup job initialized`);
-} else {
-  console.log(`${YELLOW}!${RESET} Auth cleanup job not initialized`);
-}
-
-// Run async checks
-checkDatabase().then(() => {
-  console.log('\n=== Summary ===');
-  if (allGood) {
-    console.log(`${GREEN}All security fixes are deployed!${RESET}`);
-  } else {
-    console.log(`${YELLOW}Some security features need activation:${RESET}`);
-    console.log('1. Run migrations: npx knex migrate:latest');
-    console.log('2. Update server.js to use auth-enhanced routes');
-    console.log('3. Restart the container');
-  }
-});

backend/scripts/create-admin.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+
+/**
+ * Script to create an admin user
+ * Usage: node scripts/create-admin.js --email admin@example.com --username admin --password yourpassword
+ * 
+ * If no password is provided, a random one will be generated and displayed
+ */
+
+require('dotenv').config();
+const bcrypt = require('bcrypt');
+const { db } = require('../src/database/db');
+const crypto = require('crypto');
+
+// Parse command line arguments
+const args = process.argv.slice(2);
+const getArg = (name) => {
+  const index = args.findIndex(arg => arg === `--${name}`);
+  return index !== -1 && args[index + 1] ? args[index + 1] : null;
+};
+
+const email = getArg('email');
+const username = getArg('username') || email?.split('@')[0] || 'admin';
+let password = getArg('password');
+
+// Validate email
+if (!email) {
+  console.error('Error: Email is required. Use --email admin@example.com');
+  process.exit(1);
+}
+
+// Generate password if not provided
+if (!password) {
+  password = crypto.randomBytes(12).toString('base64').slice(0, 16);
+  console.log(`Generated password: ${password}`);
+  console.log('Please save this password securely!');
+}
+
+async function createAdmin() {
+  try {
+    // Check if user already exists
+    const existingUser = await db('admin_users')
+      .where('email', email)
+      .orWhere('username', username)
+      .first();
+
+    if (existingUser) {
+      console.error(`Error: User with email "${email}" or username "${username}" already exists`);
+      process.exit(1);
+    }
+
+    // Hash password
+    const passwordHash = await bcrypt.hash(password, 10);
+
+    // Create admin user
+    await db('admin_users').insert({
+      username,
+      email,
+      password_hash: passwordHash,
+      is_active: true,
+      created_at: new Date(),
+      updated_at: new Date()
+    });
+
+    console.log(`✅ Admin user created successfully!`);
+    console.log(`   Email: ${email}`);
+    console.log(`   Username: ${username}`);
+    console.log(`   Login URL: ${process.env.ADMIN_URL || 'http://localhost:3000'}/admin/login`);
+    
+    process.exit(0);
+  } catch (error) {
+    console.error('Error creating admin user:', error.message);
+    process.exit(1);
+  }
+}
+
+createAdmin();

backend/scripts/create-test-event.js

@@ -36,7 +36,8 @@ async function createTestEvent() {
     await db('events').where('slug', eventData.slug).delete();
     
     // Insert new event
-    const [eventId] = await db('events').insert(eventData);
+    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!');

backend/scripts/debug-500-errors.js

@@ -0,0 +1,92 @@
+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-event-photos.js

@@ -1,56 +0,0 @@
-const knex = require('knex')({
-  client: 'sqlite3',
-  connection: { filename: '/app/data/photo_sharing.db' },
-  useNullAsDefault: true
-});
-
-async function debugEventPhotos() {
-  try {
-    // Get all photos for event 12
-    const photos = await knex('photos')
-      .where('event_id', 12)
-      .select('id', 'filename', 'path', 'thumbnail_path')
-      .orderBy('id');
-    
-    console.log('Total photos for event 12:', photos.length);
-    console.log('\nSample photos:');
-    
-    // Show first few and specific IDs that were failing
-    const sampleIds = [1686, 1687, 1688, 1689, 1715, 1717, 1718, 1719];
-    const samples = photos.filter(p => sampleIds.includes(p.id));
-    
-    samples.forEach(p => {
-      console.log(`\nID ${p.id}: ${p.filename}`);
-      console.log(`  Path: ${p.path}`);
-      console.log(`  Thumbnail: ${p.thumbnail_path}`);
-    });
-    
-    // Check for any photos without thumbnails
-    const noThumbs = photos.filter(p => !p.thumbnail_path);
-    if (noThumbs.length > 0) {
-      console.log(`\nPhotos without thumbnails: ${noThumbs.length}`);
-      noThumbs.forEach(p => console.log(`  ID ${p.id}: ${p.filename}`));
-    }
-    
-    // Check file existence for failing photos
-    const fs = require('fs').promises;
-    console.log('\nChecking file existence for samples:');
-    
-    for (const photo of samples) {
-      const thumbPath = `/app/storage/${photo.thumbnail_path}`;
-      try {
-        await fs.access(thumbPath);
-        console.log(`✓ ID ${photo.id}: Thumbnail exists at ${thumbPath}`);
-      } catch (err) {
-        console.log(`✗ ID ${photo.id}: Thumbnail NOT FOUND at ${thumbPath}`);
-      }
-    }
-    
-  } catch (error) {
-    console.error('Error:', error);
-  } finally {
-    knex.destroy();
-  }
-}
-
-debugEventPhotos();

backend/scripts/debug-photos-enhanced.js

@@ -1,81 +0,0 @@
-#!/usr/bin/env node
-
-const sqlite3 = require('sqlite3').verbose();
-const fs = require('fs');
-const path = require('path');
-
-// 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');
-});
-
-// Query for photos with IDs 1688 and 1689 where event_id = 12
-const query = `
-  SELECT p.id, p.filename, p.path, p.thumbnail_path, p.event_id, 
-         e.slug as event_slug, e.is_active, e.is_archived
-  FROM photos p
-  JOIN events e ON p.event_id = e.id
-  WHERE p.id IN (1688, 1689) AND p.event_id = 12
-`;
-
-console.log('Executing query to get photo details with event information...\n');
-
-db.all(query, [], (err, rows) => {
-  if (err) {
-    console.error('Error executing query:', err.message);
-    db.close();
-    process.exit(1);
-  }
-  
-  console.log(`Found ${rows.length} photo(s):\n`);
-  
-  if (rows.length === 0) {
-    console.log('No photos found matching the criteria.');
-  } else {
-    rows.forEach((row) => {
-      console.log('=== Photo ID:', row.id, '===');
-      console.log('Filename:', row.filename);
-      console.log('DB Path:', row.path);
-      console.log('DB Thumbnail Path:', row.thumbnail_path);
-      console.log('Event ID:', row.event_id);
-      console.log('Event Slug:', row.event_slug);
-      console.log('Event is_active:', row.is_active);
-      console.log('Event is_archived:', row.is_archived);
-      
-      // Check file existence
-      const storageBase = '/app/storage';
-      const eventStatusDir = row.is_active ? 'active' : 'archived';
-      
-      // Check full image path
-      const fullImagePath1 = path.join(storageBase, row.path);
-      const fullImagePath2 = path.join(storageBase, 'events', eventStatusDir, row.path);
-      
-      console.log('\nChecking full image paths:');
-      console.log(`  Path 1: ${fullImagePath1} - ${fs.existsSync(fullImagePath1) ? 'EXISTS' : 'NOT FOUND'}`);
-      console.log(`  Path 2: ${fullImagePath2} - ${fs.existsSync(fullImagePath2) ? 'EXISTS' : 'NOT FOUND'}`);
-      
-      // Check thumbnail path
-      const thumbnailPath = path.join(storageBase, row.thumbnail_path);
-      console.log('\nChecking thumbnail path:');
-      console.log(`  ${thumbnailPath} - ${fs.existsSync(thumbnailPath) ? 'EXISTS' : 'NOT FOUND'}`);
-      
-      console.log('\n---\n');
-    });
-  }
-  
-  // Close the database connection
-  db.close((err) => {
-    if (err) {
-      console.error('Error closing database:', err.message);
-    } else {
-      console.log('Database connection closed.');
-    }
-  });
-});

backend/scripts/debug-photos.js

@@ -1,56 +0,0 @@
-#!/usr/bin/env node
-
-const sqlite3 = require('sqlite3').verbose();
-const path = require('path');
-
-// 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.');
-});
-
-// Query for photos with IDs 1688 and 1689 where event_id = 12
-const query = `
-  SELECT id, filename, path, thumbnail_path 
-  FROM photos 
-  WHERE id IN (1688, 1689) AND event_id = 12
-`;
-
-console.log('\nExecuting query:', query);
-
-db.all(query, [], (err, rows) => {
-  if (err) {
-    console.error('Error executing query:', err.message);
-    db.close();
-    process.exit(1);
-  }
-  
-  console.log(`\nFound ${rows.length} photo(s):\n`);
-  
-  if (rows.length === 0) {
-    console.log('No photos found matching the criteria.');
-  } else {
-    rows.forEach((row) => {
-      console.log('Photo ID:', row.id);
-      console.log('Filename:', row.filename);
-      console.log('Path:', row.path);
-      console.log('Thumbnail Path:', row.thumbnail_path);
-      console.log('---');
-    });
-  }
-  
-  // Close the database connection
-  db.close((err) => {
-    if (err) {
-      console.error('Error closing database:', err.message);
-    } else {
-      console.log('\nDatabase connection closed.');
-    }
-  });
-});

backend/scripts/deploy-auth-security.sh

@@ -1,132 +0,0 @@
-#!/bin/bash
-
-# Authentication Security Enhancement Deployment Script
-# This script helps safely deploy auth security enhancements
-
-set -e
-
-echo "=== PicPeak Authentication Security Deployment ==="
-echo ""
-
-# Color codes
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-NC='\033[0m' # No Color
-
-# Check if we're in the backend directory
-if [ ! -f "package.json" ] || [ ! -d "src" ]; then
-    echo -e "${RED}Error: Must run from backend directory${NC}"
-    exit 1
-fi
-
-# Function to prompt for confirmation
-confirm() {
-    read -p "$1 (y/n): " -n 1 -r
-    echo
-    if [[ ! $REPLY =~ ^[Yy]$ ]]; then
-        echo -e "${YELLOW}Deployment cancelled${NC}"
-        exit 1
-    fi
-}
-
-echo "This script will help deploy authentication security enhancements"
-echo ""
-echo "Current deployment phase options:"
-echo "1. Run database migrations only (safe)"
-echo "2. Test enhanced auth endpoints"
-echo "3. Switch to enhanced auth (full deployment)"
-echo "4. Rollback to original auth"
-echo ""
-
-read -p "Select phase (1-4): " PHASE
-
-case $PHASE in
-    1)
-        echo -e "${GREEN}Phase 1: Running database migrations${NC}"
-        confirm "Run migrations?"
-        
-        echo "Creating backup..."
-        cp database.db database.db.backup.$(date +%Y%m%d_%H%M%S) 2>/dev/null || true
-        
-        echo "Running migrations..."
-        npx knex migrate:latest
-        
-        echo -e "${GREEN}✓ Migrations completed${NC}"
-        echo "New tables added: login_attempts"
-        echo "New columns added to admin_users: password_changed_at, last_login_ip"
-        ;;
-        
-    2)
-        echo -e "${GREEN}Phase 2: Testing enhanced auth${NC}"
-        
-        # Check if server is running
-        if ! curl -s http://localhost:3001/health > /dev/null; then
-            echo -e "${RED}Server not running on port 3001${NC}"
-            exit 1
-        fi
-        
-        echo "Running auth security tests..."
-        node scripts/test-auth-security.js
-        
-        echo ""
-        echo "Test endpoints manually:"
-        echo "- Login: POST /api/auth/admin/login"
-        echo "- Logout: POST /api/auth/logout"
-        echo "- Session: GET /api/auth/session"
-        ;;
-        
-    3)
-        echo -e "${YELLOW}Phase 3: Full deployment${NC}"
-        echo "This will switch to enhanced authentication"
-        confirm "Deploy enhanced auth?"
-        
-        # Check if migrations are run
-        if ! npx knex migrate:status | grep -q "015_add_login_attempts_table"; then
-            echo -e "${RED}Error: Migrations not run. Run phase 1 first.${NC}"
-            exit 1
-        fi
-        
-        echo "Updating server.js to use enhanced auth..."
-        # This is where you'd update the imports
-        # For safety, we'll just show what needs to be done
-        
-        echo -e "${YELLOW}Manual steps required:${NC}"
-        echo "1. Edit server.js"
-        echo "2. Change: const authRoutes = require('./src/routes/auth');"
-        echo "   To: const authRoutes = require('./src/routes/auth-enhanced');"
-        echo "3. Restart the application"
-        echo ""
-        echo "After restart, the enhanced auth will be active with:"
-        echo "- Account lockout protection"
-        echo "- Login attempt tracking"
-        echo "- Enhanced security logging"
-        ;;
-        
-    4)
-        echo -e "${RED}Phase 4: Rollback${NC}"
-        confirm "Rollback auth changes?"
-        
-        echo "Rolling back to original auth..."
-        echo ""
-        echo -e "${YELLOW}Manual steps required:${NC}"
-        echo "1. Edit server.js"
-        echo "2. Change: const authRoutes = require('./src/routes/auth-enhanced');"
-        echo "   To: const authRoutes = require('./src/routes/auth');"
-        echo "3. Restart the application"
-        echo ""
-        echo "Optional: Clear lockouts"
-        echo "sqlite3 database.db \"DELETE FROM login_attempts WHERE success = 0\""
-        ;;
-        
-    *)
-        echo -e "${RED}Invalid option${NC}"
-        exit 1
-        ;;
-esac
-
-echo ""
-echo -e "${GREEN}Done!${NC}"
-echo ""
-echo "Monitor logs after any changes:"
-echo "docker-compose logs -f backend | grep -i auth"

backend/scripts/fix-default-themes.js

@@ -1,37 +0,0 @@
-const path = require('path');
-require('dotenv').config({ path: path.join(__dirname, '../.env') });
-const { db } = require('../src/database/db');
-
-async function fixDefaultThemes() {
-  try {
-    console.log('Fixing events with "default" theme...');
-    
-    // Find all events with "default" as color_theme
-    const eventsToFix = await db('events')
-      .where('color_theme', 'default')
-      .select('id', 'event_name');
-    
-    console.log(`Found ${eventsToFix.length} events to fix`);
-    
-    if (eventsToFix.length > 0) {
-      // Update them to null so they use the global theme
-      await db('events')
-        .where('color_theme', 'default')
-        .update({ color_theme: null });
-      
-      console.log('Updated events to use global theme');
-      
-      eventsToFix.forEach(event => {
-        console.log(`- Fixed event: ${event.event_name} (ID: ${event.id})`);
-      });
-    }
-    
-    console.log('Theme fix completed successfully');
-    process.exit(0);
-  } catch (error) {
-    console.error('Error fixing themes:', error);
-    process.exit(1);
-  }
-}
-
-fixDefaultThemes();

backend/scripts/fix-production-issues.js

@@ -0,0 +1,145 @@
+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/monitor-auth-health.js

@@ -1,136 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Monitor authentication health after deployment
- * Run this after activating enhanced auth to watch for issues
- */
-
-const { db } = require('../src/database/db');
-
-console.log('=== Authentication Health Monitor ===\n');
-console.log('Monitoring auth system... (Press Ctrl+C to stop)\n');
-
-// Color codes
-const GREEN = '\x1b[32m';
-const RED = '\x1b[31m';
-const YELLOW = '\x1b[33m';
-const RESET = '\x1b[0m';
-
-let previousStats = {
-  totalAttempts: 0,
-  failedAttempts: 0,
-  lockedAccounts: 0
-};
-
-async function getAuthStats() {
-  try {
-    const stats = {};
-    
-    // Total login attempts in last hour
-    const totalAttempts = await db('login_attempts')
-      .where('attempt_time', '>', new Date(Date.now() - 60 * 60 * 1000).toISOString())
-      .count('id as count')
-      .first();
-    stats.totalAttempts = totalAttempts.count || 0;
-    
-    // Failed attempts in last hour
-    const failedAttempts = await db('login_attempts')
-      .where('attempt_time', '>', new Date(Date.now() - 60 * 60 * 1000).toISOString())
-      .where('success', false)
-      .count('id as count')
-      .first();
-    stats.failedAttempts = failedAttempts.count || 0;
-    
-    // Currently locked accounts
-    const recentWindow = new Date(Date.now() - 15 * 60 * 1000);
-    const lockedAccounts = await db('login_attempts')
-      .select('identifier')
-      .where('success', false)
-      .where('attempt_time', '>=', recentWindow.toISOString())
-      .groupBy('identifier')
-      .havingRaw('COUNT(*) >= 5');
-    stats.lockedAccounts = lockedAccounts.length;
-    
-    // Success rate
-    stats.successRate = stats.totalAttempts > 0 
-      ? ((stats.totalAttempts - stats.failedAttempts) / stats.totalAttempts * 100).toFixed(1)
-      : 100;
-    
-    // Recent failures (last 5 minutes)
-    const recentFailures = await db('login_attempts')
-      .where('success', false)
-      .where('attempt_time', '>', new Date(Date.now() - 5 * 60 * 1000).toISOString())
-      .orderBy('attempt_time', 'desc')
-      .limit(5)
-      .select('identifier', 'ip_address', 'attempt_time');
-    stats.recentFailures = recentFailures;
-    
-    return stats;
-  } catch (error) {
-    return { error: error.message };
-  }
-}
-
-async function displayStats() {
-  const stats = await getAuthStats();
-  
-  if (stats.error) {
-    console.log(`${RED}Error: ${stats.error}${RESET}`);
-    console.log('Enhanced auth might not be active yet.\n');
-    return;
-  }
-  
-  // Clear console for clean display
-  console.clear();
-  console.log('=== Authentication Health Monitor ===\n');
-  console.log(new Date().toLocaleString());
-  console.log('─'.repeat(50));
-  
-  // Display metrics
-  console.log(`\n📊 Last Hour Statistics:`);
-  console.log(`   Total Login Attempts: ${stats.totalAttempts}`);
-  console.log(`   Failed Attempts: ${stats.failedAttempts}`);
-  console.log(`   Success Rate: ${stats.successRate}%`);
-  console.log(`   Currently Locked: ${stats.lockedAccounts} accounts`);
-  
-  // Alerts
-  if (stats.failedAttempts > previousStats.failedAttempts + 10) {
-    console.log(`\n${RED}⚠️  ALERT: Spike in failed login attempts!${RESET}`);
-  }
-  
-  if (stats.lockedAccounts > 5) {
-    console.log(`\n${YELLOW}⚠️  WARNING: Multiple accounts locked (${stats.lockedAccounts})${RESET}`);
-  }
-  
-  if (stats.successRate < 50) {
-    console.log(`\n${RED}⚠️  ALERT: Low success rate (${stats.successRate}%)${RESET}`);
-  }
-  
-  // Recent failures
-  if (stats.recentFailures && stats.recentFailures.length > 0) {
-    console.log(`\n📋 Recent Failed Attempts (last 5 min):`);
-    stats.recentFailures.forEach(failure => {
-      const time = new Date(failure.attempt_time).toLocaleTimeString();
-      console.log(`   ${time} - ${failure.identifier} from ${failure.ip_address}`);
-    });
-  }
-  
-  // Health status
-  console.log(`\n✅ Status: ${stats.failedAttempts === 0 ? 'Healthy' : 'Active'}`);
-  console.log('\nPress Ctrl+C to stop monitoring\n');
-  
-  previousStats = stats;
-}
-
-// Monitor every 10 seconds
-setInterval(displayStats, 10000);
-
-// Initial display
-displayStats();
-
-// Graceful shutdown
-process.on('SIGINT', async () => {
-  console.log('\nStopping monitor...');
-  await db.destroy();
-  process.exit(0);
-});

backend/scripts/safe-auth-deployment.js

@@ -1,269 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Safe Authentication Deployment Script
- * Carefully activates auth security with multiple safety checks
- */
-
-const { db } = require('../src/database/db');
-const logger = require('../src/utils/logger');
-
-console.log('=== Safe Authentication Security Deployment ===\n');
-
-// Color codes
-const GREEN = '\x1b[32m';
-const RED = '\x1b[31m';
-const YELLOW = '\x1b[33m';
-const BLUE = '\x1b[34m';
-const RESET = '\x1b[0m';
-
-async function runSafetyChecks() {
-  console.log(`${BLUE}Running pre-deployment safety checks...${RESET}\n`);
-  
-  const checks = {
-    databaseConnected: false,
-    adminUsersExist: false,
-    activeSessionsExist: false,
-    migrationsReady: true,
-    diskSpace: true
-  };
-
-  try {
-    // Check 1: Database connection
-    await db.raw('SELECT 1');
-    checks.databaseConnected = true;
-    console.log(`${GREEN}✓${RESET} Database connection healthy`);
-  } catch (e) {
-    console.log(`${RED}✗${RESET} Database connection failed`);
-    return checks;
-  }
-
-  try {
-    // Check 2: Admin users exist
-    const adminCount = await db('admin_users').count('id as count').first();
-    checks.adminUsersExist = adminCount.count > 0;
-    console.log(`${GREEN}✓${RESET} Found ${adminCount.count} admin users`);
-  } catch (e) {
-    console.log(`${RED}✗${RESET} Could not check admin users`);
-  }
-
-  try {
-    // Check 3: Check for active sessions (optional warning)
-    const recentLogins = await db('access_logs')
-      .where('action', 'login_success')
-      .where('timestamp', '>', new Date(Date.now() - 60 * 60 * 1000).toISOString())
-      .count('id as count')
-      .first();
-    
-    if (recentLogins.count > 0) {
-      checks.activeSessionsExist = true;
-      console.log(`${YELLOW}!${RESET} Warning: ${recentLogins.count} active sessions in last hour`);
-    } else {
-      console.log(`${GREEN}✓${RESET} No recent active sessions`);
-    }
-  } catch (e) {
-    // Table might not exist yet, that's ok
-    console.log(`${GREEN}✓${RESET} No access logs table yet (expected)`);
-  }
-
-  try {
-    // Check 4: Check if migrations would conflict
-    const tables = await db.raw(`
-      SELECT name FROM sqlite_master 
-      WHERE type='table' AND name IN ('login_attempts')
-    `);
-    
-    if (tables.length > 0) {
-      console.log(`${YELLOW}!${RESET} login_attempts table already exists`);
-      checks.migrationsReady = false;
-    } else {
-      console.log(`${GREEN}✓${RESET} Ready to create login_attempts table`);
-    }
-  } catch (e) {
-    console.log(`${RED}✗${RESET} Could not check existing tables`);
-    checks.migrationsReady = false;
-  }
-
-  return checks;
-}
-
-async function backupDatabase() {
-  console.log(`\n${BLUE}Creating database backup...${RESET}`);
-  
-  try {
-    const fs = require('fs').promises;
-    const path = require('path');
-    
-    const dbPath = process.env.DB_PATH || './data/database.db';
-    const backupPath = `${dbPath}.backup.${Date.now()}`;
-    
-    await fs.copyFile(dbPath, backupPath);
-    console.log(`${GREEN}✓${RESET} Database backed up to: ${path.basename(backupPath)}`);
-    return backupPath;
-  } catch (e) {
-    console.log(`${YELLOW}!${RESET} Could not create backup: ${e.message}`);
-    return null;
-  }
-}
-
-async function runMigrations() {
-  console.log(`\n${BLUE}Running database migrations...${RESET}`);
-  
-  try {
-    // Run migrations
-    const knex = db;
-    await knex.migrate.latest();
-    
-    console.log(`${GREEN}✓${RESET} Migrations completed successfully`);
-    
-    // Verify tables exist
-    const loginAttempts = await db('login_attempts').count().first();
-    console.log(`${GREEN}✓${RESET} login_attempts table created`);
-    
-    const adminColumns = await db('admin_users').columnInfo();
-    if (adminColumns.password_changed_at) {
-      console.log(`${GREEN}✓${RESET} Security columns added to admin_users`);
-    }
-    
-    return true;
-  } catch (e) {
-    console.log(`${RED}✗${RESET} Migration failed: ${e.message}`);
-    return false;
-  }
-}
-
-async function testEnhancedAuth() {
-  console.log(`\n${BLUE}Testing enhanced authentication (without activating)...${RESET}`);
-  
-  try {
-    // Test that enhanced modules load correctly
-    const authSecurity = require('../src/utils/authSecurity');
-    const authEnhanced = require('../src/middleware/auth-enhanced');
-    const authRoutes = require('../src/routes/auth-enhanced');
-    
-    console.log(`${GREEN}✓${RESET} Enhanced auth modules load correctly`);
-    
-    // Test lockout logic (without real data)
-    const lockoutStatus = await authSecurity.checkAccountLockout('test-user-that-doesnt-exist');
-    console.log(`${GREEN}✓${RESET} Account lockout check works: ${lockoutStatus.isLocked ? 'locked' : 'not locked'}`);
-    
-    // Test generic error
-    const error = authSecurity.getGenericAuthError();
-    console.log(`${GREEN}✓${RESET} Generic error message: "${error}"`);
-    
-    return true;
-  } catch (e) {
-    console.log(`${RED}✗${RESET} Enhanced auth test failed: ${e.message}`);
-    return false;
-  }
-}
-
-async function createDeploymentInstructions() {
-  console.log(`\n${BLUE}Deployment Instructions:${RESET}\n`);
-  
-  const instructions = `
-${GREEN}Step 1: Update server.js${RESET}
-  Change:
-    ${YELLOW}const authRoutes = require('./src/routes/auth');${RESET}
-  To:
-    ${GREEN}const authRoutes = require('./src/routes/auth-enhanced');${RESET}
-
-  Add after database initialization:
-    ${GREEN}const { initializeCleanupJob } = require('./src/utils/authSecurity');
-    initializeCleanupJob();${RESET}
-
-${GREEN}Step 2: Update middleware imports (if needed)${RESET}
-  In files using adminAuth, change:
-    ${YELLOW}const { adminAuth } = require('../middleware/auth');${RESET}
-  To:
-    ${GREEN}const { adminAuth } = require('../middleware/auth-enhanced');${RESET}
-
-${GREEN}Step 3: Restart the application${RESET}
-  ${BLUE}docker-compose restart backend${RESET}
-  or
-  ${BLUE}pm2 restart picpeak-backend${RESET}
-
-${GREEN}Step 4: Monitor logs${RESET}
-  ${BLUE}docker-compose logs -f backend | grep -i auth${RESET}
-  
-${YELLOW}Rollback if needed:${RESET}
-  Revert server.js changes and restart
-`;
-
-  console.log(instructions);
-}
-
-async function main() {
-  try {
-    // Step 1: Run safety checks
-    const checks = await runSafetyChecks();
-    
-    if (!checks.databaseConnected) {
-      console.log(`\n${RED}Cannot proceed: Database not connected${RESET}`);
-      process.exit(1);
-    }
-    
-    if (checks.activeSessionsExist) {
-      console.log(`\n${YELLOW}Warning: There are active user sessions.`);
-      console.log(`Consider deploying during low-traffic period.${RESET}`);
-    }
-    
-    // Step 2: Backup database
-    const backupPath = await backupDatabase();
-    
-    // Step 3: Run migrations
-    console.log(`\n${YELLOW}Ready to run migrations. This will:`);
-    console.log(`- Create login_attempts table`);
-    console.log(`- Add security columns to admin_users`);
-    console.log(`No existing data will be modified.${RESET}\n`);
-    
-    const readline = require('readline').createInterface({
-      input: process.stdin,
-      output: process.stdout
-    });
-    
-    readline.question('Continue with migrations? (y/n): ', async (answer) => {
-      if (answer.toLowerCase() !== 'y') {
-        console.log(`${YELLOW}Deployment cancelled${RESET}`);
-        readline.close();
-        await db.destroy();
-        return;
-      }
-      
-      const migrationSuccess = await runMigrations();
-      
-      if (!migrationSuccess) {
-        console.log(`\n${RED}Migrations failed. Database backup available at: ${backupPath}${RESET}`);
-        readline.close();
-        await db.destroy();
-        return;
-      }
-      
-      // Step 4: Test enhanced auth
-      const authTestSuccess = await testEnhancedAuth();
-      
-      if (!authTestSuccess) {
-        console.log(`\n${YELLOW}Enhanced auth tests failed, but migrations succeeded.`);
-        console.log(`Review the errors before activating enhanced auth.${RESET}`);
-      }
-      
-      // Step 5: Show deployment instructions
-      await createDeploymentInstructions();
-      
-      console.log(`\n${GREEN}✓ Pre-deployment complete!${RESET}`);
-      console.log(`${YELLOW}Enhanced auth is ready but NOT YET ACTIVE.${RESET}`);
-      console.log(`Follow the instructions above to activate when ready.\n`);
-      
-      readline.close();
-      await db.destroy();
-    });
-    
-  } catch (error) {
-    console.error(`${RED}Deployment script error:${RESET}`, error);
-    await db.destroy();
-    process.exit(1);
-  }
-}
-
-// Run the deployment
-main();

backend/scripts/seed-categories.js

@@ -1,47 +0,0 @@
-const path = require('path');
-require('dotenv').config({ path: path.join(__dirname, '../.env') });
-const { db } = require('../src/database/db');
-
-async function seedCategories() {
-  try {
-    console.log('Seeding default categories...');
-    
-    const defaultCategories = [
-      { name: 'Portraits', slug: 'portraits' },
-      { name: 'Group Photos', slug: 'group-photos' },
-      { name: 'Ceremony', slug: 'ceremony' },
-      { name: 'Reception', slug: 'reception' },
-      { name: 'Dancing', slug: 'dancing' },
-      { name: 'Candids', slug: 'candids' },
-      { name: 'Details', slug: 'details' },
-      { name: 'Getting Ready', slug: 'getting-ready' }
-    ];
-    
-    for (const category of defaultCategories) {
-      // Check if category already exists
-      const existing = await db('photo_categories')
-        .where({ slug: category.slug, is_global: true })
-        .first();
-      
-      if (!existing) {
-        await db('photo_categories').insert({
-          name: category.name,
-          slug: category.slug,
-          is_global: true,
-          event_id: null
-        });
-        console.log(`Created category: ${category.name}`);
-      } else {
-        console.log(`Category already exists: ${category.name}`);
-      }
-    }
-    
-    console.log('Default categories seeded successfully');
-    process.exit(0);
-  } catch (error) {
-    console.error('Error seeding categories:', error);
-    process.exit(1);
-  }
-}
-
-seedCategories();

backend/scripts/test-admin-photo.js

@@ -1,55 +0,0 @@
-const axios = require('axios');
-
-async function testAdminPhotoEndpoint() {
-  try {
-    // First login
-    console.log('1. Logging in as admin...');
-    const loginResponse = await axios.post('http://localhost:3000/api/admin/auth/login', {
-      username: 'admin',
-      password: 'admin123'
-    });
-    
-    const token = loginResponse.data.token;
-    console.log('✓ Login successful, got token');
-    
-    // Test thumbnail endpoint
-    console.log('\n2. Testing thumbnail endpoint for photo 1688...');
-    try {
-      const thumbResponse = await axios.get('http://localhost:3000/api/admin/events/12/thumbnail/1688', {
-        headers: {
-          Authorization: `Bearer ${token}`
-        },
-        responseType: 'arraybuffer'
-      });
-      
-      console.log('✓ Thumbnail request successful');
-      console.log('  Response headers:', thumbResponse.headers);
-      console.log('  Data size:', thumbResponse.data.length, 'bytes');
-    } catch (error) {
-      console.error('✗ Thumbnail request failed:', error.response?.status, error.response?.data?.toString());
-    }
-    
-    // Test from frontend proxy port
-    console.log('\n3. Testing through nginx proxy (port 3001)...');
-    try {
-      const proxyResponse = await axios.get('http://localhost:3001/api/admin/events/12/thumbnail/1688', {
-        headers: {
-          Authorization: `Bearer ${token}`,
-          Origin: 'http://localhost:3005'
-        },
-        responseType: 'arraybuffer'
-      });
-      
-      console.log('✓ Proxy request successful');
-      console.log('  Response headers:', proxyResponse.headers);
-      console.log('  Data size:', proxyResponse.data.length, 'bytes');
-    } catch (error) {
-      console.error('✗ Proxy request failed:', error.response?.status, error.response?.data?.toString());
-    }
-    
-  } catch (error) {
-    console.error('Error:', error.message);
-  }
-}
-
-testAdminPhotoEndpoint();

backend/scripts/test-auth-deployment.sh

@@ -1,146 +0,0 @@
-#!/bin/bash
-
-# Test authentication deployment
-# This script tests the enhanced auth without affecting production
-
-set -e
-
-echo "=== Testing Authentication Deployment ==="
-echo ""
-
-# Color codes
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-NC='\033[0m' # No Color
-
-# Configuration
-API_URL="http://localhost:3001/api"
-TEST_USER="admin"
-TEST_PASS="wrong-password"
-
-echo -e "${BLUE}This script will test the authentication system${NC}"
-echo "It will make failed login attempts to test lockout"
-echo ""
-
-# Check if server is running
-echo -e "${BLUE}Checking server status...${NC}"
-if curl -s -f "$API_URL/../health" > /dev/null; then
-    echo -e "${GREEN}✓ Server is running${NC}"
-else
-    echo -e "${RED}✗ Server not accessible at $API_URL${NC}"
-    exit 1
-fi
-
-# Function to make login attempt
-make_login_attempt() {
-    local username=$1
-    local password=$2
-    local expected_status=$3
-    
-    response=$(curl -s -w "\n%{http_code}" -X POST "$API_URL/auth/admin/login" \
-        -H "Content-Type: application/json" \
-        -d "{\"username\":\"$username\",\"password\":\"$password\"}")
-    
-    http_code=$(echo "$response" | tail -n1)
-    body=$(echo "$response" | head -n-1)
-    
-    if [ "$http_code" -eq "$expected_status" ]; then
-        echo -e "${GREEN}✓${NC} Got expected status $http_code"
-        return 0
-    else
-        echo -e "${RED}✗${NC} Expected $expected_status, got $http_code"
-        echo "Response: $body"
-        return 1
-    fi
-}
-
-# Test 1: Normal failed login
-echo -e "\n${BLUE}Test 1: Normal failed login${NC}"
-make_login_attempt "$TEST_USER" "$TEST_PASS" 401
-
-# Test 2: Multiple failed attempts (testing lockout)
-echo -e "\n${BLUE}Test 2: Testing account lockout (5 attempts)${NC}"
-echo "Making 4 more failed attempts..."
-
-for i in {2..5}; do
-    echo -n "Attempt $i: "
-    make_login_attempt "$TEST_USER" "$TEST_PASS" 401
-    sleep 1
-done
-
-# Test 3: 6th attempt should be locked
-echo -e "\n${BLUE}Test 3: 6th attempt (should be locked if enhanced auth active)${NC}"
-echo -n "Attempt 6: "
-
-response=$(curl -s -w "\n%{http_code}" -X POST "$API_URL/auth/admin/login" \
-    -H "Content-Type: application/json" \
-    -d "{\"username\":\"$TEST_USER\",\"password\":\"$TEST_PASS\"}")
-
-http_code=$(echo "$response" | tail -n1)
-body=$(echo "$response" | head -n-1)
-
-if [ "$http_code" -eq "423" ]; then
-    echo -e "${GREEN}✓ Account locked as expected!${NC}"
-    echo -e "${GREEN}Enhanced auth is ACTIVE${NC}"
-    echo "Lockout message: $(echo $body | jq -r '.error')"
-    ENHANCED_ACTIVE=true
-elif [ "$http_code" -eq "401" ]; then
-    echo -e "${YELLOW}! Still got 401 - Enhanced auth NOT active${NC}"
-    echo "Original auth is still in use"
-    ENHANCED_ACTIVE=false
-else
-    echo -e "${RED}✗ Unexpected status: $http_code${NC}"
-    echo "Response: $body"
-fi
-
-# Test 4: Check if we can query login attempts
-echo -e "\n${BLUE}Test 4: Checking login attempts table${NC}"
-
-if [ "$ENHANCED_ACTIVE" = true ]; then
-    # This would need database access, so we'll check via API behavior
-    echo -e "${GREEN}✓ Login tracking is active${NC}"
-else
-    echo -e "${YELLOW}! Login tracking not active (migrations might not be run)${NC}"
-fi
-
-# Test 5: Test logout endpoint
-echo -e "\n${BLUE}Test 5: Testing logout endpoint${NC}"
-
-# First need a valid token (this assumes you have one for testing)
-# For now, just check if endpoint exists
-logout_response=$(curl -s -w "\n%{http_code}" -X POST "$API_URL/auth/logout" \
-    -H "Authorization: Bearer invalid-token")
-
-logout_code=$(echo "$logout_response" | tail -n1)
-
-if [ "$logout_code" -eq "200" ] || [ "$logout_code" -eq "401" ]; then
-    echo -e "${GREEN}✓ Logout endpoint exists${NC}"
-else
-    echo -e "${YELLOW}! Logout endpoint might not be active${NC}"
-fi
-
-# Summary
-echo -e "\n${BLUE}=== Summary ===${NC}"
-if [ "$ENHANCED_ACTIVE" = true ]; then
-    echo -e "${GREEN}✅ Enhanced authentication is ACTIVE${NC}"
-    echo "- Account lockout protection: Working"
-    echo "- Login attempt tracking: Active"
-    echo "- Enhanced security: Enabled"
-    echo ""
-    echo -e "${YELLOW}Note: Test account might be locked for 30 minutes${NC}"
-else
-    echo -e "${YELLOW}⚠️  Enhanced authentication is NOT ACTIVE${NC}"
-    echo "- Using original auth system"
-    echo "- No lockout protection"
-    echo "- No login tracking"
-    echo ""
-    echo "To activate:"
-    echo "1. Run migrations: docker exec wedding-photo-sharing-backend-1 npx knex migrate:latest"
-    echo "2. Update server.js to use auth-enhanced routes"
-    echo "3. Restart: docker-compose restart backend"
-fi
-
-echo ""
-echo "Test complete!"

backend/scripts/test-auth-security.js

@@ -1,112 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Test script to verify authentication security enhancements
- */
-
-console.log('=== Testing Authentication Security Enhancements ===\n');
-
-const { 
-  checkAccountLockout,
-  getGenericAuthError,
-  MAX_LOGIN_ATTEMPTS,
-  LOCKOUT_DURATION
-} = require('../src/utils/authSecurity');
-
-let passed = 0;
-let failed = 0;
-
-function test(description, fn) {
-  try {
-    const result = fn();
-    if (result || result === undefined) {
-      console.log(`✅ ${description}`);
-      passed++;
-    } else {
-      console.log(`❌ ${description}`);
-      failed++;
-    }
-  } catch (error) {
-    console.log(`❌ ${description} - Error: ${error.message}`);
-    failed++;
-  }
-}
-
-// Test generic error message
-console.log('Testing generic error messages:');
-test('Generic error prevents user enumeration', () => {
-  const error = getGenericAuthError();
-  return error === 'Invalid credentials';
-});
-
-// Test constants
-console.log('\nTesting security constants:');
-test('Max login attempts is reasonable', () => MAX_LOGIN_ATTEMPTS === 5);
-test('Lockout duration is 30 minutes', () => LOCKOUT_DURATION === 30 * 60 * 1000);
-
-// Test JWT structure
-console.log('\nTesting JWT token claims:');
-const jwt = require('jsonwebtoken');
-const testToken = jwt.sign({
-  id: 1,
-  username: 'testuser',
-  type: 'admin',
-  ip: '127.0.0.1',
-  loginTime: Date.now()
-}, 'test-secret', {
-  expiresIn: '24h',
-  issuer: 'picpeak-auth'
-});
-
-const decoded = jwt.verify(testToken, 'test-secret', { complete: true });
-test('Token has issuer claim', () => decoded.payload.iss === 'picpeak-auth');
-test('Token has IP claim', () => decoded.payload.ip === '127.0.0.1');
-test('Token has loginTime claim', () => typeof decoded.payload.loginTime === 'number');
-test('Token expires in 24 hours', () => {
-  const exp = decoded.payload.exp;
-  const iat = decoded.payload.iat;
-  return (exp - iat) === 24 * 60 * 60;
-});
-
-// Test auth middleware logic
-console.log('\nTesting auth middleware logic:');
-test('Token type validation works', () => {
-  const adminToken = { type: 'admin' };
-  const galleryToken = { type: 'gallery' };
-  const invalidToken = { type: 'invalid' };
-  
-  return adminToken.type === 'admin' && 
-         galleryToken.type === 'gallery' &&
-         invalidToken.type !== 'admin' && 
-         invalidToken.type !== 'gallery';
-});
-
-// Test IP validation logic
-console.log('\nTesting IP validation:');
-test('IP mismatch is detected', () => {
-  const tokenIp = '192.168.1.100';
-  const currentIp = '10.0.0.50';
-  return tokenIp !== currentIp;
-});
-
-// Test password change detection
-console.log('\nTesting password change detection:');
-test('Token issued before password change is invalid', () => {
-  const tokenIssuedAt = Math.floor(Date.now() / 1000) - 3600; // 1 hour ago
-  const passwordChangedAt = Math.floor(Date.now() / 1000) - 1800; // 30 minutes ago
-  return tokenIssuedAt < passwordChangedAt;
-});
-
-// Summary
-console.log('\n=== Test Summary ===');
-console.log(`Total tests: ${passed + failed}`);
-console.log(`Passed: ${passed}`);
-console.log(`Failed: ${failed}`);
-
-if (failed === 0) {
-  console.log('\n✅ All authentication security tests passed!');
-  process.exit(0);
-} else {
-  console.log('\n❌ Some tests failed. Review the implementation.');
-  process.exit(1);
-}

backend/scripts/test-auth-v2-fixes.js

@@ -1,146 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Test Authentication V2 Security Fixes
- */
-
-console.log('=== Testing Authentication V2 Fixes ===\n');
-
-const jwt = require('jsonwebtoken');
-
-let passed = 0;
-let failed = 0;
-
-function test(description, fn) {
-  try {
-    const result = fn();
-    if (result || result === undefined) {
-      console.log(`✅ ${description}`);
-      passed++;
-    } else {
-      console.log(`❌ ${description}`);
-      failed++;
-    }
-  } catch (error) {
-    console.log(`❌ ${description} - Error: ${error.message}`);
-    failed++;
-  }
-}
-
-async function runTests() {
-  // Test 1: Rate Limiting Security
-  console.log('1. Testing Rate Limiting Security:');
-  const { hasValidAdminToken } = require('../src/utils/rateLimitSecurity');
-  
-  // Mock requests
-  const validAdminReq = {
-    path: '/api/admin/events',
-    headers: {
-      authorization: 'Bearer ' + jwt.sign({ id: 1, type: 'admin' }, process.env.JWT_SECRET || 'test')
-    },
-    ip: '127.0.0.1'
-  };
-  
-  const invalidTokenReq = {
-    path: '/api/admin/events',
-    headers: {
-      authorization: 'Bearer invalid.token.here'
-    },
-    ip: '127.0.0.1'
-  };
-  
-  const galleryTokenReq = {
-    path: '/api/admin/events',
-    headers: {
-      authorization: 'Bearer ' + jwt.sign({ id: 1, type: 'gallery' }, process.env.JWT_SECRET || 'test')
-    },
-    ip: '127.0.0.1'
-  };
-  
-  test('Valid admin token skips rate limit', () => hasValidAdminToken(validAdminReq) === true);
-  test('Invalid token applies rate limit', () => hasValidAdminToken(invalidTokenReq) === false);
-  test('Gallery token cannot bypass admin rate limit', () => hasValidAdminToken(galleryTokenReq) === false);
-  
-  // Test 2: Password Validation
-  console.log('\n2. Testing Password Validation:');
-  const { validatePassword, validatePasswordInContext } = require('../src/utils/passwordValidation');
-  
-  const weakPassword = validatePassword('weak123');
-  test('Weak password is rejected', () => !weakPassword.valid);
-  test('Weak password has errors', () => weakPassword.errors.length > 0);
-  
-  const strongPassword = validatePassword('Str0ng!P@ssw0rd123');
-  test('Strong password is accepted', () => strongPassword.valid);
-  test('Strong password has good score', () => strongPassword.score >= 3);
-  
-  const shortPassword = validatePassword('Short!1');
-  test('Short password is rejected', () => !shortPassword.valid && 
-    shortPassword.errors.some(e => e.includes('12 characters')));
-  
-  const noSpecialChar = validatePassword('NoSpecialChar123');
-  test('Password without special char is rejected', () => !noSpecialChar.valid &&
-    noSpecialChar.errors.some(e => e.includes('special character')));
-  
-  // Context validation
-  const adminContext = validatePasswordInContext('Admin123!Pass', 'admin', { username: 'admin' });
-  test('Admin password with username is rejected', () => !adminContext.valid);
-  
-  const galleryContext = validatePasswordInContext('Event123!Pass', 'gallery', { eventName: 'event' });
-  test('Gallery password with event name is rejected', () => !galleryContext.valid);
-  
-  // Test 3: Token Revocation
-  console.log('\n3. Testing Token Revocation:');
-  const { isTokenRevoked } = require('../src/utils/tokenRevocation');
-  
-  const testToken = {
-    jti: 'test-123',
-    id: 1,
-    type: 'admin',
-    iat: Math.floor(Date.now() / 1000)
-  };
-  
-  // This would need database setup to fully test
-  test('Token revocation check runs', async () => {
-    try {
-      await isTokenRevoked(testToken);
-      return true;
-    } catch (e) {
-      // Expected if tables don't exist yet
-      return true;
-    }
-  });
-  
-  // Test 4: Bcrypt Rounds
-  console.log('\n4. Testing Configurable Bcrypt:');
-  const { getBcryptRounds, PASSWORD_CONFIG } = require('../src/utils/passwordValidation');
-  
-  test('Bcrypt rounds are configurable', () => {
-    const rounds = getBcryptRounds();
-    return rounds >= 10 && rounds <= 14;
-  });
-  
-  test('Default bcrypt rounds is 12', () => {
-    return PASSWORD_CONFIG.bcryptRounds === 12 || 
-           PASSWORD_CONFIG.bcryptRounds === parseInt(process.env.BCRYPT_ROUNDS);
-  });
-  
-  // Summary
-  console.log('\n=== Test Summary ===');
-  console.log(`Total tests: ${passed + failed}`);
-  console.log(`Passed: ${passed}`);
-  console.log(`Failed: ${failed}`);
-  
-  if (failed === 0) {
-    console.log('\n✅ All authentication V2 tests passed!');
-    process.exit(0);
-  } else {
-    console.log('\n❌ Some tests failed. Review the implementation.');
-    process.exit(1);
-  }
-}
-
-// Run tests
-runTests().catch(error => {
-  console.error('Test error:', error);
-  process.exit(1);
-});

backend/scripts/test-enhanced-auth-docker.js

@@ -1,75 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Test enhanced authentication features in Docker
- */
-
-const { db } = require('../src/database/db');
-const { 
-  checkAccountLockout,
-  trackFailedAttempt,
-  trackSuccessfulLogin
-} = require('../src/utils/authSecurity');
-
-console.log('=== Testing Enhanced Auth Features ===\n');
-
-async function testAuthFeatures() {
-  try {
-    // Test 1: Check if tables exist
-    console.log('1. Checking database tables...');
-    const loginAttempts = await db('login_attempts').count().first();
-    console.log('✓ login_attempts table exists');
-    
-    // Test 2: Test failed attempt tracking
-    console.log('\n2. Testing failed attempt tracking...');
-    await trackFailedAttempt('test-user', '127.0.0.1', 'Test User Agent');
-    const attempts = await db('login_attempts')
-      .where('identifier', 'test-user')
-      .count()
-      .first();
-    console.log(`✓ Failed attempt tracked (${attempts.count} total)`);
-    
-    // Test 3: Test lockout check
-    console.log('\n3. Testing lockout detection...');
-    
-    // Add 4 more failures to trigger lockout
-    for (let i = 0; i < 4; i++) {
-      await trackFailedAttempt('test-user', '127.0.0.1', 'Test User Agent');
-    }
-    
-    const lockoutStatus = await checkAccountLockout('test-user');
-    console.log(`✓ Lockout check works: ${lockoutStatus.isLocked ? 'LOCKED' : 'NOT LOCKED'}`);
-    
-    if (lockoutStatus.isLocked) {
-      console.log(`  Remaining lockout time: ${lockoutStatus.remainingTime} seconds`);
-    }
-    
-    // Test 4: Test successful login tracking
-    console.log('\n4. Testing successful login tracking...');
-    await trackSuccessfulLogin('test-user', '127.0.0.1', 'Test User Agent');
-    console.log('✓ Successful login tracked');
-    
-    // Test 5: Check if auth routes load
-    console.log('\n5. Testing enhanced auth routes...');
-    try {
-      const authRoutes = require('../src/routes/auth-enhanced');
-      console.log('✓ Enhanced auth routes load successfully');
-    } catch (e) {
-      console.log('✗ Error loading enhanced auth routes:', e.message);
-    }
-    
-    // Clean up test data
-    await db('login_attempts').where('identifier', 'test-user').delete();
-    console.log('\n✓ Test data cleaned up');
-    
-    console.log('\n✅ Enhanced auth features are working correctly!');
-    console.log('\nNext step: Update server.js to use enhanced auth routes');
-    
-  } catch (error) {
-    console.error('\n❌ Test failed:', error);
-  } finally {
-    await db.destroy();
-  }
-}
-
-testAuthFeatures();

backend/scripts/test-jwt-validation.js

@@ -1,98 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Test script to verify JWT_SECRET validation works correctly
- * This ensures our security fix doesn't break production
- */
-
-const { spawn } = require('child_process');
-const path = require('path');
-
-console.log('=== Testing JWT_SECRET Validation ===\n');
-
-// Test 1: Server should fail to start without JWT_SECRET
-console.log('Test 1: Starting server without JWT_SECRET...');
-const test1 = spawn('node', [path.join(__dirname, '..', 'server.js')], {
-  env: { ...process.env, JWT_SECRET: '' },
-  stdio: 'pipe'
-});
-
-let test1Output = '';
-test1.stderr.on('data', (data) => {
-  test1Output += data.toString();
-});
-
-test1.on('close', (code) => {
-  if (code === 1 && test1Output.includes('Missing required environment variable: JWT_SECRET')) {
-    console.log('✅ Test 1 PASSED: Server correctly refuses to start without JWT_SECRET\n');
-    runTest2();
-  } else {
-    console.log('❌ Test 1 FAILED: Server should have failed to start');
-    console.log('Exit code:', code);
-    console.log('Output:', test1Output);
-    process.exit(1);
-  }
-});
-
-// Test 2: Server should fail with insecure default value
-function runTest2() {
-  console.log('Test 2: Starting server with insecure JWT_SECRET...');
-  const test2 = spawn('node', [path.join(__dirname, '..', 'server.js')], {
-    env: { ...process.env, JWT_SECRET: 'your-secret-key' },
-    stdio: 'pipe'
-  });
-
-  let test2Output = '';
-  test2.stderr.on('data', (data) => {
-    test2Output += data.toString();
-  });
-
-  test2.on('close', (code) => {
-    if (code === 1 && test2Output.includes('JWT_SECRET is set to the insecure default value')) {
-      console.log('✅ Test 2 PASSED: Server correctly refuses insecure JWT_SECRET\n');
-      runTest3();
-    } else {
-      console.log('❌ Test 2 FAILED: Server should have rejected insecure JWT_SECRET');
-      console.log('Exit code:', code);
-      console.log('Output:', test2Output);
-      process.exit(1);
-    }
-  });
-}
-
-// Test 3: Verify protectedImages functions work with valid JWT_SECRET
-function runTest3() {
-  console.log('Test 3: Testing protectedImages functions...');
-  
-  // Set a valid JWT_SECRET for this test
-  process.env.JWT_SECRET = 'test-secret-key-that-is-long-enough-for-security';
-  
-  try {
-    // Load the module to test
-    const protectedImagesPath = path.join(__dirname, '..', 'src', 'routes', 'protectedImages.js');
-    delete require.cache[protectedImagesPath]; // Clear cache to ensure fresh load
-    
-    // This will throw if JWT_SECRET is not available
-    require(protectedImagesPath);
-    
-    console.log('✅ Test 3 PASSED: protectedImages module loads successfully with valid JWT_SECRET\n');
-    
-    console.log('=== All Tests Passed! ===');
-    console.log('\nThe JWT_SECRET validation is working correctly.');
-    console.log('Production systems must have JWT_SECRET set to a secure value.');
-    process.exit(0);
-  } catch (error) {
-    console.log('❌ Test 3 FAILED: Error loading protectedImages module');
-    console.log('Error:', error.message);
-    process.exit(1);
-  }
-}
-
-// Give the first test some time to complete
-setTimeout(() => {
-  if (test1.exitCode === null) {
-    console.log('❌ Test 1 TIMEOUT: Server did not exit as expected');
-    test1.kill();
-    process.exit(1);
-  }
-}, 5000);

backend/scripts/test-routes-after-security-fix.js

@@ -1,171 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Test script to verify routes work correctly after SQL security fixes
- * Run this before deploying to production
- */
-
-const request = require('supertest');
-const app = require('../src/app');
-const { db } = require('../src/database/db');
-const jwt = require('jsonwebtoken');
-
-// Generate admin token for testing
-const adminToken = jwt.sign(
-  { id: 1, username: 'admin', role: 'admin' },
-  process.env.JWT_SECRET || 'test-secret'
-);
-
-console.log('=== Testing Routes After SQL Security Fixes ===\n');
-
-let passed = 0;
-let failed = 0;
-
-async function testRoute(description, testFn) {
-  try {
-    await testFn();
-    console.log(`✅ ${description}`);
-    passed++;
-  } catch (error) {
-    console.log(`❌ ${description}`);
-    console.error(`   Error: ${error.message}`);
-    failed++;
-  }
-}
-
-async function runTests() {
-  // Test Dashboard Stats (uses whereRaw fixes)
-  await testRoute('Dashboard stats endpoint', async () => {
-    const res = await request(app)
-      .get('/api/admin/dashboard/stats')
-      .set('Authorization', `Bearer ${adminToken}`)
-      .expect(200);
-    
-    if (!res.body.hasOwnProperty('activeEvents')) {
-      throw new Error('Missing activeEvents in response');
-    }
-  });
-
-  // Test Analytics with days parameter (uses sanitizeDays)
-  await testRoute('Analytics with valid days parameter', async () => {
-    const res = await request(app)
-      .get('/api/admin/dashboard/analytics?days=7')
-      .set('Authorization', `Bearer ${adminToken}`)
-      .expect(200);
-    
-    if (!res.body.chartData || res.body.chartData.length !== 7) {
-      throw new Error('Invalid chart data');
-    }
-  });
-
-  // Test Analytics with SQL injection attempt in days
-  await testRoute('Analytics rejects SQL injection in days parameter', async () => {
-    const res = await request(app)
-      .get('/api/admin/dashboard/analytics?days=7; DROP TABLE events; --')
-      .set('Authorization', `Bearer ${adminToken}`)
-      .expect(200);
-    
-    // Should default to 7 days
-    if (res.body.chartData.length !== 7) {
-      throw new Error('Days parameter not properly sanitized');
-    }
-  });
-
-  // Test Event search with normal text (uses escapeLikePattern)
-  await testRoute('Event search with normal text', async () => {
-    const res = await request(app)
-      .get('/api/admin/events?search=test')
-      .set('Authorization', `Bearer ${adminToken}`)
-      .expect(200);
-    
-    if (!res.body.hasOwnProperty('events')) {
-      throw new Error('Missing events in response');
-    }
-  });
-
-  // Test Event search with special characters
-  await testRoute('Event search with special characters', async () => {
-    const res = await request(app)
-      .get('/api/admin/events?search=50%_test')
-      .set('Authorization', `Bearer ${adminToken}`)
-      .expect(200);
-    
-    // Should handle special chars safely
-    if (!res.body.hasOwnProperty('events')) {
-      throw new Error('Failed to handle special characters');
-    }
-  });
-
-  // Test Event search with SQL injection attempt
-  await testRoute('Event search prevents SQL injection', async () => {
-    const res = await request(app)
-      .get("/api/admin/events?search=' OR 1=1 --")
-      .set('Authorization', `Bearer ${adminToken}`)
-      .expect(200);
-    
-    // Should return empty results, not all events
-    if (!res.body.hasOwnProperty('events')) {
-      throw new Error('SQL injection may not be prevented');
-    }
-  });
-
-  // Test Photo search (if event exists)
-  await testRoute('Photo search functionality', async () => {
-    // First check if we have any events
-    const event = await db('events').first();
-    if (event) {
-      const res = await request(app)
-        .get(`/api/admin/events/${event.id}/photos?search=test`)
-        .set('Authorization', `Bearer ${adminToken}`)
-        .expect(200);
-      
-      if (!res.body.hasOwnProperty('photos')) {
-        throw new Error('Missing photos in response');
-      }
-    }
-  });
-
-  // Test Activity endpoint
-  await testRoute('Activity log endpoint', async () => {
-    const res = await request(app)
-      .get('/api/admin/dashboard/activity?limit=10')
-      .set('Authorization', `Bearer ${adminToken}`)
-      .expect(200);
-    
-    if (!Array.isArray(res.body)) {
-      throw new Error('Activity should return array');
-    }
-  });
-
-  // Test Health endpoint
-  await testRoute('Health check endpoint', async () => {
-    const res = await request(app)
-      .get('/api/admin/dashboard/health')
-      .set('Authorization', `Bearer ${adminToken}`)
-      .expect(200);
-    
-    if (!res.body.hasOwnProperty('overall')) {
-      throw new Error('Missing overall health status');
-    }
-  });
-
-  // Summary
-  console.log('\n=== Test Summary ===');
-  console.log(`Total tests: ${passed + failed}`);
-  console.log(`Passed: ${passed}`);
-  console.log(`Failed: ${failed}`);
-
-  if (failed === 0) {
-    console.log('\n✅ All route tests passed! Safe to deploy.');
-    process.exit(0);
-  } else {
-    console.log('\n❌ Some tests failed. Review the fixes before deploying.');
-    process.exit(1);
-  }
-}
-
-// Run tests
-runTests().catch(error => {
-  console.error('Test runner error:', error);
-  process.exit(1);
-});

backend/scripts/test-sql-security.js

@@ -1,108 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Test script to verify SQL security fixes work correctly
- * Tests both functionality and security of the fixes
- */
-
-const { 
-  sanitizeDays, 
-  escapeLikePattern,
-  validateSortColumn,
-  validateSortOrder 
-} = require('../src/utils/sqlSecurity');
-
-console.log('=== Testing SQL Security Utilities ===\n');
-
-let passed = 0;
-let failed = 0;
-
-function test(description, fn) {
-  try {
-    const result = fn();
-    if (result) {
-      console.log(`✅ ${description}`);
-      passed++;
-    } else {
-      console.log(`❌ ${description}`);
-      failed++;
-    }
-  } catch (error) {
-    console.log(`❌ ${description} - Error: ${error.message}`);
-    failed++;
-  }
-}
-
-// Test sanitizeDays
-console.log('Testing sanitizeDays function:');
-test('Valid number returns same number', () => sanitizeDays(7) === 7);
-test('String number is parsed correctly', () => sanitizeDays('30') === 30);
-test('Invalid input returns default 7', () => sanitizeDays('abc') === 7);
-test('Negative number returns 1', () => sanitizeDays(-5) === 1);
-test('Zero returns 1', () => sanitizeDays(0) === 1);
-test('Large number is capped at 365', () => sanitizeDays(500) === 365);
-test('NaN returns default 7', () => sanitizeDays(NaN) === 7);
-test('Null returns default 7', () => sanitizeDays(null) === 7);
-test('Undefined returns default 7', () => sanitizeDays(undefined) === 7);
-
-// Test escapeLikePattern
-console.log('\nTesting escapeLikePattern function:');
-test('Normal text unchanged', () => escapeLikePattern('hello world') === 'hello world');
-test('Percent sign escaped', () => escapeLikePattern('50%') === '50\\%');
-test('Underscore escaped', () => escapeLikePattern('user_name') === 'user\\_name');
-test('Backslash escaped', () => escapeLikePattern('path\\to\\file') === 'path\\\\to\\\\file');
-test('Multiple special chars escaped', () => escapeLikePattern('50%_test\\') === '50\\%\\_test\\\\');
-test('Empty string returns empty', () => escapeLikePattern('') === '');
-test('Null returns empty string', () => escapeLikePattern(null) === '');
-test('Undefined returns empty string', () => escapeLikePattern(undefined) === '');
-test('Single quotes escaped', () => escapeLikePattern("O'Brien") === "O''Brien");
-
-// Test SQL injection attempts
-console.log('\nTesting SQL injection prevention:');
-test('SQL injection attempt with quotes', () => {
-  const malicious = "'; DROP TABLE users; --";
-  const escaped = escapeLikePattern(malicious);
-  return escaped === "''; DROP TABLE users; --" && escaped.includes("''");
-});
-
-test('SQL injection with LIKE wildcards', () => {
-  const malicious = "%' OR 1=1 --";
-  const escaped = escapeLikePattern(malicious);
-  return escaped === "\\%'' OR 1=1 --";
-});
-
-test('Days parameter injection attempt', () => {
-  const malicious = "7; DROP TABLE events; --";
-  return sanitizeDays(malicious) === 7;
-});
-
-// Test validateSortColumn
-console.log('\nTesting validateSortColumn function:');
-const allowedColumns = ['name', 'date', 'size'];
-test('Valid column accepted', () => validateSortColumn('name', allowedColumns, 'date') === 'name');
-test('Invalid column returns default', () => validateSortColumn('price', allowedColumns, 'date') === 'date');
-test('Null returns default', () => validateSortColumn(null, allowedColumns, 'date') === 'date');
-test('Empty string returns default', () => validateSortColumn('', allowedColumns, 'date') === 'date');
-
-// Test validateSortOrder
-console.log('\nTesting validateSortOrder function:');
-test('Valid asc accepted', () => validateSortOrder('asc') === 'asc');
-test('Valid ASC accepted', () => validateSortOrder('ASC') === 'asc');
-test('Valid desc accepted', () => validateSortOrder('desc') === 'desc');
-test('Invalid order returns desc', () => validateSortOrder('random') === 'desc');
-test('Null returns desc', () => validateSortOrder(null) === 'desc');
-test('Empty returns desc', () => validateSortOrder('') === 'desc');
-
-// Summary
-console.log('\n=== Test Summary ===');
-console.log(`Total tests: ${passed + failed}`);
-console.log(`Passed: ${passed}`);
-console.log(`Failed: ${failed}`);
-
-if (failed === 0) {
-  console.log('\n✅ All tests passed! SQL security utilities are working correctly.');
-  process.exit(0);
-} else {
-  console.log('\n❌ Some tests failed. Please check the implementation.');
-  process.exit(1);
-}

backend/scripts/test-upload.js

@@ -1,59 +0,0 @@
-const axios = require('axios');
-const FormData = require('form-data');
-const fs = require('fs');
-const path = require('path');
-
-async function testUpload() {
-  try {
-    // First login
-    console.log('1. Logging in as admin...');
-    const loginResponse = await axios.post('http://localhost:3000/api/admin/auth/login', {
-      username: 'admin',
-      password: 'admin123'
-    });
-    
-    const token = loginResponse.data.token;
-    console.log('✓ Login successful');
-    
-    // Create a test image file
-    const testImagePath = path.join(__dirname, 'test-image.png');
-    const imageBuffer = Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==', 'base64');
-    fs.writeFileSync(testImagePath, imageBuffer);
-    
-    // Test upload
-    console.log('\n2. Testing upload with category_id=7...');
-    const form = new FormData();
-    form.append('photos', fs.createReadStream(testImagePath), 'test-image.png');
-    form.append('category_id', '7');
-    
-    console.log('Form data headers:', form.getHeaders());
-    
-    try {
-      const uploadResponse = await axios.post(
-        'http://localhost:3000/api/admin/events/12/upload',
-        form,
-        {
-          headers: {
-            ...form.getHeaders(),
-            'Authorization': `Bearer ${token}`
-          }
-        }
-      );
-      
-      console.log('✓ Upload successful:', uploadResponse.data);
-    } catch (error) {
-      console.error('✗ Upload failed:', error.response?.status, error.response?.data);
-      if (error.response?.data) {
-        console.error('Error details:', JSON.stringify(error.response.data, null, 2));
-      }
-    }
-    
-    // Clean up
-    fs.unlinkSync(testImagePath);
-    
-  } catch (error) {
-    console.error('Error:', error.message);
-  }
-}
-
-testUpload();

backend/scripts/verify-auth-activation.js

@@ -1,106 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Verify enhanced authentication is active and working
- */
-
-const { db } = require('../src/database/db');
-
-console.log('=== Verifying Enhanced Authentication Activation ===\n');
-
-async function verifyAuth() {
-  const results = {
-    databaseTables: false,
-    serverConfig: false,
-    lockoutActive: false,
-    cleanupActive: false
-  };
-  
-  try {
-    // 1. Check database tables
-    console.log('1. Checking database tables...');
-    const hasLoginAttempts = await db.schema.hasTable('login_attempts');
-    const hasSecurityColumns = await db.schema.hasColumn('admin_users', 'password_changed_at');
-    
-    if (hasLoginAttempts && hasSecurityColumns) {
-      results.databaseTables = true;
-      console.log('✓ Auth tables and columns exist');
-      
-      // Count attempts
-      const attempts = await db('login_attempts').count().first();
-      console.log(`  Total login attempts tracked: ${attempts['count(*)'] || 0}`);
-    } else {
-      console.log('✗ Auth tables missing');
-    }
-    
-    // 2. Check server configuration
-    console.log('\n2. Checking server configuration...');
-    const fs = require('fs');
-    const serverContent = fs.readFileSync('./server.js', 'utf8');
-    
-    if (serverContent.includes("require('./src/routes/auth-enhanced')")) {
-      results.serverConfig = true;
-      console.log('✓ Server using enhanced auth routes');
-    } else {
-      console.log('✗ Server using original auth routes');
-    }
-    
-    if (serverContent.includes('initializeCleanupJob')) {
-      results.cleanupActive = true;
-      console.log('✓ Cleanup job initialized');
-    } else {
-      console.log('✗ Cleanup job not initialized');
-    }
-    
-    // 3. Test lockout functionality
-    console.log('\n3. Testing lockout functionality...');
-    const { checkAccountLockout } = require('../src/utils/authSecurity');
-    
-    // Check a test account
-    const lockoutTest = await checkAccountLockout('lockout-test-user');
-    console.log(`✓ Lockout check functional: ${lockoutTest.isLocked ? 'locked' : 'not locked'}`);
-    results.lockoutActive = true;
-    
-    // 4. Check recent activity
-    console.log('\n4. Recent authentication activity...');
-    const recentAttempts = await db('login_attempts')
-      .orderBy('attempt_time', 'desc')
-      .limit(5);
-    
-    if (recentAttempts.length > 0) {
-      console.log('Recent login attempts:');
-      recentAttempts.forEach(attempt => {
-        const time = new Date(attempt.attempt_time).toLocaleString();
-        console.log(`  ${time} - ${attempt.identifier} - ${attempt.success ? 'SUCCESS' : 'FAILED'}`);
-      });
-    } else {
-      console.log('No login attempts recorded yet');
-    }
-    
-    // Summary
-    console.log('\n=== Summary ===');
-    const allGood = Object.values(results).every(v => v === true);
-    
-    if (allGood) {
-      console.log('✅ Enhanced authentication is FULLY ACTIVE!');
-      console.log('\nFeatures enabled:');
-      console.log('- Account lockout protection (5 attempts)');
-      console.log('- Login attempt tracking');
-      console.log('- Enhanced token validation');
-      console.log('- Session management');
-      console.log('- Automatic cleanup of old records');
-    } else {
-      console.log('⚠️  Some features not active:');
-      Object.entries(results).forEach(([key, value]) => {
-        console.log(`  ${key}: ${value ? '✓' : '✗'}`);
-      });
-    }
-    
-  } catch (error) {
-    console.error('Verification error:', error);
-  } finally {
-    await db.destroy();
-  }
-}
-
-verifyAuth();

backend/scripts/verify-sql-fixes.js

@@ -1,80 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Verification script to check SQL queries are built correctly
- * This simulates the query building without running the full app
- */
-
-const { 
-  sanitizeDays, 
-  escapeLikePattern,
-  validateSortColumn,
-  validateSortOrder 
-} = require('../src/utils/sqlSecurity');
-
-console.log('=== Verifying SQL Security Fixes ===\n');
-
-// Test 1: Verify date range queries
-console.log('1. Testing date range query building:');
-console.log('   Input days: "7; DROP TABLE events; --"');
-const safeDays = sanitizeDays("7; DROP TABLE events; --");
-console.log('   Sanitized days:', safeDays);
-console.log('   ✅ SQL injection attempt neutralized\n');
-
-// Test 2: Verify LIKE pattern escaping
-console.log('2. Testing LIKE pattern escaping:');
-const testPatterns = [
-  "normal search",
-  "50%_wildcard",
-  "'; DROP TABLE users; --",
-  "test\\path",
-  "O'Brien"
-];
-
-testPatterns.forEach(pattern => {
-  const escaped = escapeLikePattern(pattern);
-  console.log(`   "${pattern}" → "${escaped}"`);
-});
-console.log('   ✅ All patterns safely escaped\n');
-
-// Test 3: Simulate date query building
-console.log('3. Simulating safe date query:');
-const days = 7;
-const startDate = new Date();
-startDate.setDate(startDate.getDate() - days);
-console.log(`   WHERE timestamp >= '${startDate.toISOString()}'`);
-console.log('   ✅ Using parameterized date instead of whereRaw\n');
-
-// Test 4: Verify sort validation
-console.log('4. Testing sort column/order validation:');
-const allowedColumns = ['created_at', 'event_name', 'expires_at'];
-console.log('   Allowed columns:', allowedColumns);
-
-const testSorts = [
-  { column: 'created_at', order: 'desc' },
-  { column: 'invalid_column', order: 'asc' },
-  { column: '; DROP TABLE --', order: 'random' }
-];
-
-testSorts.forEach(({ column, order }) => {
-  const safeColumn = validateSortColumn(column, allowedColumns, 'created_at');
-  const safeOrder = validateSortOrder(order);
-  console.log(`   "${column}" ${order} → "${safeColumn}" ${safeOrder}`);
-});
-console.log('   ✅ Invalid columns/orders rejected\n');
-
-// Test 5: Show example of safe query patterns
-console.log('5. Safe Query Patterns Used:');
-console.log('   ❌ OLD: .whereRaw(`timestamp >= datetime("now", "-${days} days")`)')
-console.log('   ✅ NEW: .where("timestamp", ">=", startDate.toISOString())\n');
-
-console.log('   ❌ OLD: .where("event_name", "like", `%${search}%`)')
-console.log('   ✅ NEW: .where("event_name", "like", `%${escapeLikePattern(search)}%`)\n');
-
-console.log('=== Verification Complete ===');
-console.log('All SQL injection vulnerabilities have been addressed.');
-console.log('\nNext steps:');
-console.log('1. Test in development environment');
-console.log('2. Monitor logs during testing');
-console.log('3. Deploy with rollback plan ready');
-console.log('4. Monitor production logs after deployment');

backend/server-enhanced.js

@@ -1,32 +0,0 @@
-// This is a partial server.js showing the enhanced rate limiting
-// Only the relevant parts are shown - merge with existing server.js
-
-const { createSecureSkipFunction, logRateLimitHit } = require('./src/utils/rateLimitSecurity');
-
-// Enhanced rate limiting with secure skip function
-const limiter = rateLimit({
-  windowMs: 15 * 60 * 1000, // 15 minutes
-  max: process.env.NODE_ENV === 'development' ? 1000 : 100,
-  skip: createSecureSkipFunction(), // Use secure skip function
-  handler: (req, res) => {
-    logRateLimitHit(req, res);
-    res.status(429).json({
-      error: 'Too many requests from this IP, please try again later.'
-    });
-  },
-  standardHeaders: true, // Return rate limit info in headers
-  legacyHeaders: false, // Disable X-RateLimit headers
-});
-
-const authLimiter = rateLimit({
-  windowMs: 15 * 60 * 1000,
-  max: 5, // limit auth attempts
-  skipSuccessfulRequests: true, // Don't count successful logins
-  handler: (req, res) => {
-    logRateLimitHit(req, res);
-    res.status(429).json({
-      error: 'Too many login attempts, please try again later.',
-      retryAfter: res.getHeader('Retry-After')
-    });
-  }
-});

backend/server.js

@@ -10,10 +10,10 @@ const cors = require('cors');
 const rateLimit = require('express-rate-limit');
 const jwt = require('jsonwebtoken');
 const path = require('path');
-const { initializeDatabase } = require('./src/database/db');
+const { initializeDatabase, db } = require('./src/database/db');
 const { startFileWatcher } = require('./src/services/fileWatcher');
 const { startExpirationChecker } = require('./src/services/expirationChecker');
-const { startEmailQueueProcessor } = require('./src/services/emailProcessor');
+const { initializeTransporter, startEmailQueueProcessor } = require('./src/services/emailProcessor');
 const { maintenanceMiddleware } = require('./src/middleware/maintenance');
 const { sessionTimeoutMiddleware } = require('./src/middleware/sessionTimeout');
 const logger = require('./src/utils/logger');
@@ -28,6 +28,10 @@ const adminAuthRoutes = require('./src/routes/adminAuth');
 const app = express();
 const PORT = process.env.PORT || 3000;
 
+// Trust proxy headers (required for Traefik/nginx)
+// Set to specific number of proxies or loopback to be more secure
+app.set('trust proxy', 'loopback, linklocal, uniquelocal');
+
 // Security middleware with custom CSP
 app.use(helmet({
   contentSecurityPolicy: {
@@ -152,8 +156,25 @@ app.use('/thumbnails', require('./src/middleware/photoAuth'), setCorsHeaders, se
 app.use('/uploads', setCorsHeaders, secureStatic(path.join(__dirname, 'storage/uploads')));
 
 // Health check endpoint
-app.get('/api/health', (req, res) => {
-  res.json({ status: 'ok', timestamp: new Date().toISOString() });
+app.get('/health', async (req, res) => {
+  try {
+    // Check database connectivity
+    await db.raw('SELECT 1');
+    
+    res.json({ 
+      status: 'ok', 
+      database: 'connected',
+      timestamp: new Date().toISOString() 
+    });
+  } catch (error) {
+    logger.error('Health check failed:', error);
+    res.status(503).json({ 
+      status: 'error', 
+      database: 'disconnected',
+      error: error.message,
+      timestamp: new Date().toISOString() 
+    });
+  }
 });
 
 // Routes
@@ -189,7 +210,8 @@ async function startServer() {
     // Start expiration checker
     startExpirationChecker();
     
-    // Start email queue processor
+    // Initialize email transporter and start queue processor
+    await initializeTransporter();
     startEmailQueueProcessor();
     
     app.listen(PORT, () => {

backend/server.js.backup.1752359680463

@@ -1,167 +0,0 @@
-require('dotenv').config();
-
-// Validate critical environment variables before proceeding
-const { validateEnvironment } = require('./src/config/validateEnv');
-validateEnvironment();
-
-const express = require('express');
-const helmet = require('helmet');
-const cors = require('cors');
-const rateLimit = require('express-rate-limit');
-const jwt = require('jsonwebtoken');
-const path = require('path');
-const { initializeDatabase } = require('./src/database/db');
-const { startFileWatcher } = require('./src/services/fileWatcher');
-const { startExpirationChecker } = require('./src/services/expirationChecker');
-const { startEmailQueueProcessor } = require('./src/services/emailProcessor');
-const { maintenanceMiddleware } = require('./src/middleware/maintenance');
-const { sessionTimeoutMiddleware } = require('./src/middleware/sessionTimeout');
-const logger = require('./src/utils/logger');
-
-// Import routes
-const authRoutes = require('./src/routes/auth');
-const eventRoutes = require('./src/routes/events');
-const galleryRoutes = require('./src/routes/gallery');
-const adminRoutes = require('./src/routes/admin');
-const adminAuthRoutes = require('./src/routes/adminAuth');
-
-const app = express();
-const PORT = process.env.PORT || 3000;
-
-// Security middleware
-app.use(helmet());
-
-// CORS configuration
-const corsOptions = {
-  origin: function (origin, callback) {
-    const allowedOrigins = [
-      process.env.FRONTEND_URL || 'http://localhost:3005',
-      process.env.ADMIN_URL || 'http://localhost:3005',
-      'http://localhost:5173', // Vite dev server
-      'http://localhost:3002', // Backend server
-      'http://localhost:3001', // For API testing
-      'http://localhost:3000'  // Direct backend access
-    ];
-    
-    // Allow requests with no origin (like mobile apps or curl)
-    if (!origin || allowedOrigins.indexOf(origin) !== -1) {
-      callback(null, true);
-    } else {
-      callback(new Error('Not allowed by CORS'));
-    }
-  },
-  credentials: true
-};
-
-app.use(cors(corsOptions));
-
-// Rate limiting with admin bypass
-const limiter = rateLimit({
-  windowMs: 15 * 60 * 1000, // 15 minutes
-  max: process.env.NODE_ENV === 'development' ? 1000 : 100, // More lenient in development
-  skip: (req) => {
-    // Skip rate limiting for authenticated admin users
-    if (req.path.startsWith('/api/admin/') && req.headers.authorization) {
-      const token = req.headers.authorization.replace('Bearer ', '');
-      try {
-        const decoded = jwt.verify(token, process.env.JWT_SECRET);
-        return decoded.type === 'admin';
-      } catch (err) {
-        return false;
-      }
-    }
-    // Also skip rate limiting for public settings endpoint in development
-    if (process.env.NODE_ENV === 'development' && req.path === '/api/public/settings') {
-      return true;
-    }
-    return false;
-  }
-});
-
-const authLimiter = rateLimit({
-  windowMs: 15 * 60 * 1000,
-  max: 5 // limit auth attempts
-});
-
-// Apply rate limiting - admin routes check will skip for valid admin tokens
-app.use('/api/', limiter);
-app.use('/api/auth', authLimiter);
-
-// Body parsing middleware
-app.use(express.json());
-app.use(express.urlencoded({ extended: true }));
-
-// Maintenance mode middleware - add after body parsing but before routes
-app.use(maintenanceMiddleware);
-
-// Session timeout middleware for admin routes
-app.use('/api/admin', sessionTimeoutMiddleware);
-
-// Middleware to set CORS headers for static files
-const setCorsHeaders = (req, res, next) => {
-  res.header('Access-Control-Allow-Origin', req.headers.origin || '*');
-  res.header('Access-Control-Allow-Credentials', 'true');
-  res.header('Cross-Origin-Resource-Policy', 'cross-origin');
-  next();
-};
-
-// Static file serving for photos (protected)
-app.use('/photos', require('./src/middleware/photoAuth'), setCorsHeaders, express.static(path.join(__dirname, 'storage/events/active')));
-
-// Static file serving for thumbnails (protected)
-app.use('/thumbnails', require('./src/middleware/photoAuth'), setCorsHeaders, express.static(path.join(__dirname, 'storage/thumbnails')));
-
-// Static file serving for uploads (public - logos, favicons)
-app.use('/uploads', setCorsHeaders, express.static(path.join(__dirname, 'storage/uploads')));
-
-// Health check endpoint
-app.get('/api/health', (req, res) => {
-  res.json({ status: 'ok', timestamp: new Date().toISOString() });
-});
-
-// Routes
-app.use('/api/auth', authRoutes);
-app.use('/api/events', eventRoutes);
-app.use('/api/gallery', galleryRoutes);
-app.use('/api/admin', adminRoutes);
-app.use('/api/admin/auth', adminAuthRoutes);
-app.use('/api/admin/system', require('./src/routes/adminSystem'));
-app.use('/api/public/settings', require('./src/routes/publicSettings'));
-app.use('/api/public', require('./src/routes/publicCMS'));
-app.use('/api/images', require('./src/routes/protectedImages'));
-
-// Error handling middleware
-app.use((err, req, res, next) => {
-  logger.error(err.stack);
-  res.status(500).json({ error: 'Something went wrong!' });
-});
-
-// Initialize services
-async function startServer() {
-  try {
-    // Initialize database
-    await initializeDatabase();
-    
-    // Start file watcher
-    startFileWatcher();
-    
-    // Start expiration checker
-    startExpirationChecker();
-    
-    // Start email queue processor
-    startEmailQueueProcessor();
-    
-    app.listen(PORT, () => {
-      logger.info(`Server running on port ${PORT}`);
-      logger.info(`Admin interface: ${process.env.ADMIN_URL || 'http://localhost:3000'}`);
-      logger.info(`Frontend: ${process.env.FRONTEND_URL || 'http://localhost:3001'}`);
-    });
-  } catch (error) {
-    logger.error('Failed to start server:', error);
-    process.exit(1);
-  }
-}
-
-startServer();
-
-module.exports = app; // For testing

backend/src/database/connection-manager.js

@@ -0,0 +1,132 @@
+const knex = require('knex');
+const knexConfig = require('../../knexfile');
+const logger = require('../utils/logger');
+
+class ConnectionManager {
+  constructor() {
+    this.db = null;
+    this.reconnectAttempts = 0;
+    this.maxReconnectAttempts = 10;
+    this.reconnectDelay = 5000; // 5 seconds
+    this.isReconnecting = false;
+  }
+
+  async initialize() {
+    try {
+      this.db = knex(knexConfig);
+      
+      // Test the connection
+      await this.db.raw('SELECT 1');
+      logger.info('Database connection established successfully');
+      
+      // Set up connection error handling
+      this.setupErrorHandling();
+      
+      this.reconnectAttempts = 0;
+      return this.db;
+    } catch (error) {
+      logger.error('Failed to initialize database connection:', error);
+      throw error;
+    }
+  }
+
+  setupErrorHandling() {
+    if (!this.db) return;
+
+    // Handle connection errors
+    this.db.on('error', async (error) => {
+      logger.error('Database connection error:', error);
+      
+      if (this.shouldReconnect(error)) {
+        await this.reconnect();
+      }
+    });
+  }
+
+  shouldReconnect(error) {
+    const reconnectableErrors = [
+      'ECONNREFUSED',
+      'ETIMEDOUT',
+      'ECONNRESET',
+      'Connection terminated unexpectedly',
+      'Connection terminated'
+    ];
+    
+    return reconnectableErrors.some(msg => 
+      error.code === msg || error.message?.includes(msg)
+    );
+  }
+
+  async reconnect() {
+    if (this.isReconnecting) {
+      logger.info('Already attempting to reconnect...');
+      return;
+    }
+
+    this.isReconnecting = true;
+    
+    while (this.reconnectAttempts < this.maxReconnectAttempts) {
+      this.reconnectAttempts++;
+      
+      logger.info(`Attempting to reconnect to database (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})...`);
+      
+      try {
+        // Destroy the old connection pool
+        if (this.db) {
+          await this.db.destroy();
+        }
+        
+        // Create new connection
+        await this.initialize();
+        
+        logger.info('Successfully reconnected to database');
+        this.isReconnecting = false;
+        return;
+      } catch (error) {
+        logger.error(`Reconnection attempt ${this.reconnectAttempts} failed:`, error.message);
+        
+        if (this.reconnectAttempts < this.maxReconnectAttempts) {
+          await new Promise(resolve => setTimeout(resolve, this.reconnectDelay));
+        }
+      }
+    }
+    
+    this.isReconnecting = false;
+    logger.error('Failed to reconnect to database after maximum attempts');
+    
+    // In production, you might want to alert monitoring systems or restart the process
+    if (process.env.NODE_ENV === 'production') {
+      logger.error('Exiting process due to database connection failure');
+      process.exit(1);
+    }
+  }
+
+  getConnection() {
+    if (!this.db) {
+      throw new Error('Database connection not initialized');
+    }
+    return this.db;
+  }
+
+  async healthCheck() {
+    try {
+      await this.db.raw('SELECT 1');
+      return { healthy: true };
+    } catch (error) {
+      logger.error('Database health check failed:', error);
+      return { healthy: false, error: error.message };
+    }
+  }
+
+  async destroy() {
+    if (this.db) {
+      await this.db.destroy();
+      this.db = null;
+    }
+  }
+}
+
+// Create singleton instance
+const connectionManager = new ConnectionManager();
+
+module.exports = connectionManager;

backend/src/database/db.js

@@ -1,13 +1,8 @@
 const knex = require('knex');
-const path = require('path');
+const knexConfig = require('../../knexfile');
 
-const db = knex({
-  client: 'sqlite3',
-  connection: {
-    filename: path.join(__dirname, '../../data/photo_sharing.db')
-  },
-  useNullAsDefault: true
-});
+// Create database connection with built-in retry logic
+const db = knex(knexConfig);
 
 async function initializeDatabase() {
   // Events table
@@ -35,37 +30,42 @@ async function initializeDatabase() {
   } else {
     // Check if color_theme needs to be updated to TEXT type
     // This is needed for larger theme configurations
-    try {
-      await db.raw(`
-        CREATE TABLE IF NOT EXISTS events_new (
-          id INTEGER PRIMARY KEY AUTOINCREMENT,
-          slug TEXT UNIQUE NOT NULL,
-          event_type TEXT NOT NULL,
-          event_name TEXT NOT NULL,
-          event_date DATE NOT NULL,
-          host_email TEXT NOT NULL,
-          admin_email TEXT NOT NULL,
-          password_hash TEXT NOT NULL,
-          welcome_message TEXT,
-          color_theme TEXT,
-          share_link TEXT UNIQUE NOT NULL,
-          created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-          expires_at DATETIME NOT NULL,
-          is_active BOOLEAN DEFAULT 1,
-          is_archived BOOLEAN DEFAULT 0,
-          archive_path TEXT,
-          archived_at DATETIME,
-          allow_user_uploads BOOLEAN DEFAULT 0,
-          upload_category_id INTEGER
-        )
-      `);
-      
-      await db.raw(`INSERT INTO events_new SELECT * FROM events`);
-      await db.raw(`DROP TABLE events`);
-      await db.raw(`ALTER TABLE events_new RENAME TO events`);
-    } catch (error) {
-      // If the migration fails, it might already have been applied
-      console.log('Color theme migration may have already been applied');
+    const isPostgres = knexConfig.client === 'pg';
+    
+    if (!isPostgres) {
+      // SQLite-specific migration
+      try {
+        await db.raw(`
+          CREATE TABLE IF NOT EXISTS events_new (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            slug TEXT UNIQUE NOT NULL,
+            event_type TEXT NOT NULL,
+            event_name TEXT NOT NULL,
+            event_date DATE NOT NULL,
+            host_email TEXT NOT NULL,
+            admin_email TEXT NOT NULL,
+            password_hash TEXT NOT NULL,
+            welcome_message TEXT,
+            color_theme TEXT,
+            share_link TEXT UNIQUE NOT NULL,
+            created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+            expires_at DATETIME NOT NULL,
+            is_active BOOLEAN DEFAULT 1,
+            is_archived BOOLEAN DEFAULT 0,
+            archive_path TEXT,
+            archived_at DATETIME,
+            allow_user_uploads BOOLEAN DEFAULT 0,
+            upload_category_id INTEGER
+          )
+        `);
+        
+        await db.raw(`INSERT INTO events_new SELECT * FROM events`);
+        await db.raw(`DROP TABLE events`);
+        await db.raw(`ALTER TABLE events_new RENAME TO events`);
+      } catch (error) {
+        // If the migration fails, it might already have been applied
+        console.log('Color theme migration may have already been applied');
+      }
     }
   }
 
@@ -225,4 +225,4 @@ async function logActivity(activityType, metadata = {}, eventId = null, actor =
   }
 }
 
-module.exports = { db, initializeDatabase, logActivity };
+module.exports = { db, initializeDatabase, logActivity };

backend/src/middleware/maintenance.js

@@ -5,6 +5,36 @@ let maintenanceMode = false;
 let lastCheck = 0;
 const CACHE_DURATION = 60000; // 1 minute
 
+// Retry configuration for database queries
+const MAX_RETRIES = 3;
+const RETRY_DELAY = 1000; // 1 second
+
+async function queryWithRetry(queryFn, retries = MAX_RETRIES) {
+  for (let i = 0; i < retries; i++) {
+    try {
+      return await queryFn();
+    } catch (error) {
+      if (i === retries - 1) {
+        throw error;
+      }
+      
+      // Check if it's a connection error that might benefit from retry
+      const isConnectionError = 
+        error.message?.includes('Connection terminated') ||
+        error.message?.includes('ECONNREFUSED') ||
+        error.message?.includes('ETIMEDOUT') ||
+        error.code === 'ECONNRESET';
+      
+      if (isConnectionError) {
+        console.warn(`Database connection error, retrying in ${RETRY_DELAY}ms... (attempt ${i + 1}/${retries})`);
+        await new Promise(resolve => setTimeout(resolve, RETRY_DELAY));
+      } else {
+        throw error; // Don't retry non-connection errors
+      }
+    }
+  }
+}
+
 async function checkMaintenanceMode() {
   const now = Date.now();
   
@@ -14,18 +44,21 @@ async function checkMaintenanceMode() {
   }
   
   try {
-    const setting = await db('app_settings')
-      .where('setting_key', 'general_maintenance_mode')
-      .where('setting_type', 'general')
-      .first();
+    const setting = await queryWithRetry(async () => {
+      return await db('app_settings')
+        .where('setting_key', 'general_maintenance_mode')
+        .where('setting_type', 'general')
+        .first();
+    });
     
     maintenanceMode = setting ? (setting.setting_value === 'true' || setting.setting_value === true) : false;
     lastCheck = now;
     
     return maintenanceMode;
   } catch (error) {
-    console.error('Error checking maintenance mode:', error);
-    return false;
+    console.error('Error checking maintenance mode after retries:', error.message);
+    // Return cached value or false if no cache
+    return maintenanceMode;
   }
 }
 
@@ -52,14 +85,19 @@ async function maintenanceMiddleware(req, res, next) {
     return next();
   }
   
-  const inMaintenance = await checkMaintenanceMode();
-  
-  if (inMaintenance && !isAdminRoute) {
-    return res.status(503).json({
-      error: 'Service Unavailable',
-      message: 'The system is currently undergoing maintenance. Please try again later.',
-      maintenance: true
-    });
+  try {
+    const inMaintenance = await checkMaintenanceMode();
+    
+    if (inMaintenance && !isAdminRoute) {
+      return res.status(503).json({
+        error: 'Service Unavailable',
+        message: 'The system is currently undergoing maintenance. Please try again later.',
+        maintenance: true
+      });
+    }
+  } catch (error) {
+    // If we can't check maintenance mode, allow the request to proceed
+    console.error('Failed to check maintenance mode, allowing request:', error.message);
   }
   
   next();

backend/src/middleware/sessionTimeout.js

@@ -7,6 +7,11 @@ const sessions = new Map();
 // Default session timeout (60 minutes)
 const DEFAULT_SESSION_TIMEOUT = 60 * 60 * 1000;
 
+// Cache for session timeout setting
+let cachedTimeout = null;
+let cacheExpiry = 0;
+const CACHE_DURATION = 5 * 60 * 1000; // 5 minutes
+
 // Clean up expired sessions every 5 minutes
 setInterval(() => {
   const now = Date.now();
@@ -18,20 +23,46 @@ setInterval(() => {
 }, 5 * 60 * 1000);
 
 async function getSessionTimeout() {
+  const now = Date.now();
+  
+  // Return cached value if still valid
+  if (cachedTimeout && now < cacheExpiry) {
+    return cachedTimeout;
+  }
+  
   try {
     const setting = await db('app_settings')
       .where('setting_key', 'security_session_timeout_minutes')
-      .first();
+      .first()
+      .timeout(5000); // 5 second timeout
     
     if (setting && setting.setting_value) {
-      const minutes = parseInt(JSON.parse(setting.setting_value));
-      return minutes * 60 * 1000; // Convert to milliseconds
+      let value = setting.setting_value;
+      // Handle both string and object values
+      if (typeof value === 'string') {
+        try {
+          value = JSON.parse(value);
+        } catch (e) {
+          // If it's not JSON, try to parse as number directly
+          value = parseInt(value);
+        }
+      }
+      const minutes = parseInt(value);
+      if (!isNaN(minutes) && minutes > 0) {
+        cachedTimeout = minutes * 60 * 1000; // Convert to milliseconds
+        cacheExpiry = now + CACHE_DURATION;
+        return cachedTimeout;
+      }
     }
   } catch (error) {
-    console.error('Error getting session timeout:', error);
+    // Only log if it's not a connection error (to avoid spam)
+    if (error.code !== 'ECONNRESET' && !error.message?.includes('Connection terminated')) {
+      console.error('Error getting session timeout:', error.message);
+    }
   }
   
-  return DEFAULT_SESSION_TIMEOUT;
+  // Use cached value if available, otherwise default
+  return cachedTimeout || DEFAULT_SESSION_TIMEOUT;
 }
 
 async function sessionTimeoutMiddleware(req, res, next) {

backend/src/routes/adminArchives.js

@@ -211,12 +211,14 @@ router.post('/:id/restore', adminAuth, async (req, res) => {
                   categoriesMap.set(categoryName, existingCategory.id);
                 } else {
                   // Create the category if it doesn't exist
-                  const [newCategoryId] = await db('photo_categories').insert({
+                  const insertResult = await db('photo_categories').insert({
                     event_id: archive.id,
                     name: categoryName,
                     slug: categoryName.toLowerCase().replace(/[^a-z0-9]/g, '-'),
                     created_at: new Date()
-                  });
+                  }).returning('id');
+                  
+                  const newCategoryId = insertResult[0]?.id || insertResult[0];
                   categoriesMap.set(categoryName, newCategoryId);
                 }
               }
@@ -266,6 +268,9 @@ router.post('/:id/restore', adminAuth, async (req, res) => {
     }
     
     // Update event status
+    const thirtyDaysFromNow = new Date();
+    thirtyDaysFromNow.setDate(thirtyDaysFromNow.getDate() + 30);
+    
     await db('events')
       .where('id', req.params.id)
       .update({
@@ -273,7 +278,7 @@ router.post('/:id/restore', adminAuth, async (req, res) => {
         is_active: true,
         archive_path: null,
         archived_at: null,
-        expires_at: db.raw("datetime('now', '+30 days')") // Reset expiration
+        expires_at: thirtyDaysFromNow.toISOString() // Reset expiration - works on both DBs
       });
 
     // Log activity