feat: update CI/CD to use Bun

- Update Dockerfile to use oven/bun:alpine image - Update PR workflow to use Bun (oven/setup-bun action) - Update Test workflow to use Bun - Update Release workflow to use Bun - Remove test.yml workflow (redundant with PR workflow) - Update Docker build commands to use Bun - Docker build verified working
feat: migrate from npm to Bun
2026-04-01 00:20:49 -07:00 · 2026-04-01 00:13:15 -07:00 · 2026-03-31 23:45:38 -07:00 · 2026-03-31 23:44:43 -07:00 · 2026-04-01 06:31:42 +00:00 · 2026-03-31 23:23:01 -07:00
57 changed files with 4172 additions and 572 deletions
@@ -0,0 +1,167 @@
+# Gitea Actions Workflow Architecture
+
+This document describes the workflow architecture for version bumping, testing, and releases.
+
+## Overview
+
+The workflow architecture uses a three-step process:
+1. **PR Workflow**: Runs tests on PRs and analyzes commits for bump type
+2. **Test Workflow**: Runs unit tests on all branch pushes (except version bumps)
+3. **Release Workflow**: Bumps version, creates tags, builds Docker images, and deploys on main branch pushes
+
+## Workflow Files
+
+### 1. `.gitea/workflows/pr.yml` (Pull Request Workflow)
+
+**Trigger**: Pull requests to `main` branch
+
+**Purpose**:
+- Run unit tests on every PR (fast feedback)
+- Run acceptance tests with SQLite database
+- Analyze commits to determine bump type (major/minor/patch)
+- Comment the suggested bump type on the PR
+
+**Test Execution**:
+- **Unit Tests**: Run first, fast execution
+- **Acceptance Tests**: Run after unit tests pass, uses SQLite database
+- **Database**: SQLite with `DATABASE_URL=file:./prisma/ci.db`
+- **Secrets**: Uses `BETTER_AUTH_SECRET` for authentication
+
+**Bump Type Detection**:
+- **Major**: Breaking changes detected (`BREAKING CHANGE` or `!:` in commit messages)
+- **Minor**: Feature commits detected (`feat:` prefix)
+- **Patch**: Default for fixes and other changes
+
+### 2. `.gitea/workflows/test.yml` (Test Workflow)
+
+**Trigger**: Pushes to any branch (including main)
+
+**Purpose**:
+- Run unit tests on all branch pushes
+- Skip auto-generated version bump commits (handled by release workflow)
+
+**Key Features**:
+- Runs on all branches including main
+- Skips commits with "chore: bump version" message
+- Fast execution for quick feedback
+
+### 3. `.gitea/workflows/release.yml` (Release Workflow)
+
+**Trigger**: Pushes to `main` branch (after PR merge)
+
+**Purpose**:
+- Determine bump type from merge commit or PR commits
+- Bump version in `package.json` and `CHANGELOG.md`
+- Commit the version bump
+- Create git tag for the release
+- Run tests inside Docker container (with PostgreSQL)
+- Build production Docker image
+- Push images to registry
+- Deploy to dev environment
+
+**Key Features**:
+- Skips commits that are auto-generated version bumps
+- Uses `DOCKER_LOGIN` and `DOCKER_PASSWORD` secrets for registry auth
+- Handles existing git tags gracefully
+- Runs comprehensive tests in production-like environment
+
+## Version Bump Logic
+
+### Step 1: PR Analysis (pr.yml)
+When a PR is opened or updated:
+1. Fetch the merge base with `main`
+2. Analyze all commits in the PR
+3. Determine bump type based on commit messages:
+   - Breaking changes → major
+   - Features → minor
+   - Fixes → patch
+4. Comment the suggested bump type on the PR
+
+### Step 2: Release (release.yml)
+When a PR is merged to `main`:
+1. Check if the commit is an auto-bump (skip if so)
+2. Analyze the merge commit message or PR commits
+3. Run `node scripts/bump-version.js <type> --yes`
+4. Commit the version bump changes
+5. Create and push git tag
+6. Build and push Docker images
+
+## Environment Variables & Secrets
+
+### Required Secrets
+- `DOCKER_LOGIN`: Username for Docker registry authentication
+- `DOCKER_PASSWORD`: Password for Docker registry authentication
+- `GITEA_TOKEN` (optional): For pushing back to repo (if needed)
+
+### Environment Variables
+- `REGISTRY`: Docker registry URL (default: `docker.notsosm.art`)
+- `IMAGE_NAME`: Docker image name (default: `euchre-camp`)
+
+## Example Workflow
+
+### Scenario: Feature PR
+1. Developer opens PR with commits:
+   - "feat: add new feature"
+   - "fix: resolve edge case"
+2. PR workflow runs:
+   - Unit tests pass
+   - Bump type analysis suggests "minor"
+   - Comment posted on PR: "Suggested bump: MINOR"
+3. Developer merges PR
+4. Release workflow runs:
+   - Detects minor bump from commits
+   - Bumps version from 0.1.1 → 0.2.0
+   - Commits version bump
+   - Creates tag v0.2.0
+   - Builds and pushes Docker image
+   - Deploys to dev
+
+### Scenario: Breaking Change PR
+1. Developer opens PR with commit:
+   - "feat!: breaking API change"
+2. PR workflow runs:
+   - Detects breaking change marker
+   - Suggests "major" bump
+   - Comments on PR
+3. Developer merges PR
+4. Release workflow runs:
+   - Detects major bump
+   - Bumps version from 0.1.1 → 1.0.0
+   - Creates tag v1.0.0
+   - Proceeds with build and deploy
+
+## Database Configuration for CI
+
+### SQLite for CI Acceptance Tests
+- **Why SQLite**: No database server required, perfect for CI environments
+- **Usage**: PR workflow runs acceptance tests with SQLite database
+- **Configuration**: `DATABASE_PROVIDER=sqlite`, `DATABASE_URL=file:./prisma/ci.db`
+- **Benefits**: Fast, isolated, no external dependencies
+
+### PostgreSQL for Production
+- **Usage**: Release workflow runs tests in Docker with PostgreSQL
+- **Configuration**: Uses dummy PostgreSQL URL for Docker builds
+- **Benefits**: Production-like environment, catches PostgreSQL-specific issues
+
+### Database Provider Detection
+The application automatically detects the database provider:
+- `DATABASE_PROVIDER` environment variable (defaults to `sqlite`)
+- `prisma.ts` conditionally uses PrismaPg adapter for PostgreSQL
+- Better Auth configured with appropriate provider
+
+## Benefits
+
+1. **No CI Loops**: Version bump commits are detected and skipped
+2. **Clear Communication**: PR comments inform developers of impact
+3. **Semantic Versioning**: Automated adherence to semver rules
+4. **Traceability**: Git tags and changelog reflect all changes
+5. **Safe Releases**: Tests run before version bump and deployment
+6. **Fast CI**: SQLite tests run quickly without database server setup
+7. **Comprehensive Testing**: Both unit and acceptance tests in PR workflow
+
+## Future Enhancements
+
+- Add GitHub/Gitea Release creation
+- Slack/Discord notifications on release
+- Automatic rollback on test failure
+- Multi-environment deployment (dev/staging/prod)
@@ -0,0 +1,128 @@
+name: Pull Request
+
+on:
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  unit-tests:
+    runs-on: ubuntu-latest
+    container:
+      image: oven/bun:alpine
+      options: --user root
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Install dependencies
+        run: bun install
+
+      - name: Run unit tests
+        run: bun test
+
+  acceptance-tests:
+    runs-on: ubuntu-latest
+    needs: unit-tests
+    container:
+      image: mcr.microsoft.com/playwright:v1.58.0-jammy
+      options: --user root
+    env:
+      DATABASE_PROVIDER: sqlite
+      DATABASE_URL: file:./prisma/ci.db
+      BETTER_AUTH_SECRET: test-secret-key-for-ci-only
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Bun
+        uses: oven/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - name: Install dependencies
+        run: bun install
+
+      - name: Generate Prisma client
+        run: bun x prisma generate
+        env:
+          DATABASE_URL: postgresql://user:pass@localhost:5432/dummy
+
+      - name: Setup SQLite database
+        run: |
+          # Create SQLite database file
+          mkdir -p prisma
+          bun x prisma migrate deploy
+
+      - name: Run acceptance tests
+        run: bun run test:acceptance
+        env:
+          DATABASE_PROVIDER: sqlite
+          DATABASE_URL: file:./prisma/ci.db
+          BETTER_AUTH_SECRET: test-secret-key-for-ci-only
+
+  analyze-bump-type:
+    runs-on: ubuntu-latest
+    needs: acceptance-tests
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Analyze commits for bump type
+        id: bump_type
+        run: |
+          # Get the merge base and PR commits
+          git fetch origin main:main 2>/dev/null || true
+          MERGE_BASE=$(git merge-base HEAD main 2>/dev/null || echo "HEAD~1")
+
+          # Analyze commits in this PR
+          COMMITS=$(git log --oneline ${MERGE_BASE}..HEAD 2>/dev/null || git log --oneline -10)
+
+          echo "Commits in this PR:"
+          echo "$COMMITS"
+          echo ""
+
+          # Determine bump type
+          if echo "$COMMITS" | grep -qE "(BREAKING CHANGE|!:)"; then
+            BUMP="major"
+            REASON="Breaking change detected in commit messages"
+          elif echo "$COMMITS" | grep -qE "^feat"; then
+            BUMP="minor"
+            REASON="Feature commits detected"
+          else
+            BUMP="patch"
+            REASON="Defaulting to patch (fixes or other changes)"
+          fi
+
+          echo "Suggested bump type: $BUMP"
+          echo "Reason: $REASON"
+          echo "bump=$BUMP" >> $GITHUB_OUTPUT
+          echo "reason=$REASON" >> $GITHUB_OUTPUT
+
+      - name: Comment bump type on PR
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const bump = '${{ steps.bump_type.outputs.bump }}';
+            const reason = '${{ steps.bump_type.outputs.reason }}';
+
+            const comment = `
+            ## 🏷️ Version Bump Analysis
+
+            **Suggested bump type:** \`${bump.toUpperCase()}\`
+            **Reason:** ${reason}
+
+            This PR will bump the version to the next ${bump} version when merged.
+            `;
+
+            github.rest.issues.createComment({
+              issue_number: context.issue.number,
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              body: comment
+            });
@@ -0,0 +1,172 @@
+name: Release
+
+on:
+  push:
+    branches:
+      - main
+
+env:
+  REGISTRY: docker.notsosm.art
+  IMAGE_NAME: euchre-camp
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    # Skip if this is an auto-generated version bump commit
+    if: "!contains(github.event.head_commit.message, 'chore: bump version')"
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.GITEA_TOKEN || github.token }}
+
+      - name: Configure Git
+        run: |
+          git config user.name "Gitea Actions"
+          git config user.email "actions@gitea.com"
+
+      - name: Determine version bump type
+        id: bump_type
+        run: |
+          # Get the merge commit message or use commits since last tag
+          MERGE_MSG="${{ github.event.head_commit.message }}"
+          echo "Commit message: $MERGE_MSG"
+
+          # Determine bump type from commit message or commits
+          if echo "$MERGE_MSG" | grep -qE "(BREAKING CHANGE|!:)"; then
+            echo "bump=major" >> $GITHUB_OUTPUT
+            echo "Bump type: major (breaking change detected)"
+          elif echo "$MERGE_MSG" | grep -qE "^feat"; then
+            echo "bump=minor" >> $GITHUB_OUTPUT
+            echo "Bump type: minor (feature detected)"
+          else
+            # Check actual commits in the PR
+            LAST_TAG=$(git describe --tags --abbrev=0 2>/dev/null || echo "")
+            if [ -n "$LAST_TAG" ]; then
+              COMMITS=$(git log --oneline ${LAST_TAG}..HEAD 2>/dev/null | head -5)
+            else
+              COMMITS=$(git log --oneline | head -5)
+            fi
+            echo "Recent commits: $COMMITS"
+
+            if echo "$COMMITS" | grep -qE "BREAKING\|!:"; then
+              echo "bump=major" >> $GITHUB_OUTPUT
+              echo "Bump type: major (breaking change in commits)"
+            elif echo "$COMMITS" | grep -qE "^feat"; then
+              echo "bump=minor" >> $GITHUB_OUTPUT
+              echo "Bump type: minor (feature in commits)"
+            else
+              echo "bump=patch" >> $GITHUB_OUTPUT
+              echo "Bump type: patch (default)"
+            fi
+          fi
+
+      - name: Setup Bun
+        uses: oven/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - name: Bump version
+        id: version
+        run: |
+          BUMP="${{ steps.bump_type.outputs.bump }}"
+          echo "Bumping version: $BUMP"
+
+          # Run the bump script
+          bun run scripts/bump-version.js "$BUMP" --yes
+
+          # Get new version
+          NEW_VERSION=$(bun -e "console.log(require('./package.json').version)")
+          echo "new_version=$NEW_VERSION" >> $GITHUB_OUTPUT
+          echo "New version: $NEW_VERSION"
+
+      - name: Commit version bump
+        id: commit
+        run: |
+          git add package.json CHANGELOG.md
+          if git diff --cached --quiet; then
+            echo "No changes to commit (version may already be at target version)"
+            echo "committed=false" >> $GITHUB_OUTPUT
+          else
+            git commit -m "chore: bump version to v${{ steps.version.outputs.new_version }}"
+            git push origin main
+            echo "committed=true" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Create git tag for release
+        if: steps.commit.outputs.committed == 'true'
+        run: |
+          TAG_NAME="v${{ steps.version.outputs.new_version }}"
+          echo "Creating tag $TAG_NAME"
+          
+          # Check if tag already exists
+          if git rev-parse "$TAG_NAME" >/dev/null 2>&1; then
+            echo "Tag $TAG_NAME already exists, skipping tag creation"
+          else
+            git tag -a "$TAG_NAME" -m "Release $TAG_NAME"
+            git push origin "$TAG_NAME"
+          fi
+
+      - name: Set up Docker Buildx
+        if: steps.commit.outputs.committed == 'true'
+        uses: docker/setup-buildx-action@v3
+
+      - name: Build test-capable image
+        if: steps.commit.outputs.committed == 'true'
+        run: |
+          docker build \
+            --target test-runner \
+            --build-arg GIT_COMMIT=${{ github.sha }} \
+            -t ${{ env.IMAGE_NAME }}-test:${{ steps.version.outputs.new_version }} \
+            .
+
+      - name: Run tests inside test-capable container
+        if: steps.commit.outputs.committed == 'true'
+        run: |
+          docker run --rm \
+            -e DATABASE_URL="postgresql://user:pass@localhost:5432/dummy" \
+            ${{ env.IMAGE_NAME }}-test:${{ steps.version.outputs.new_version }} \
+            bun test
+
+      - name: Build production image
+        if: steps.commit.outputs.committed == 'true'
+        run: |
+          docker build \
+            --target runner \
+            --build-arg GIT_COMMIT=${{ github.sha }} \
+            -t ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.new_version }} \
+            -t ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:latest \
+            .
+
+      - name: Push Docker images
+        if: steps.commit.outputs.committed == 'true'
+        run: |
+          echo "Pushing to ${{ env.REGISTRY }}..."
+          # Check if we can authenticate to the registry using DOCKER_LOGIN and DOCKER_PASSWORD secrets
+          if [ -n "${{ secrets.DOCKER_LOGIN }}" ] && [ -n "${{ secrets.DOCKER_PASSWORD }}" ]; then
+            if docker login ${{ env.REGISTRY }} -u ${{ secrets.DOCKER_LOGIN }} -p ${{ secrets.DOCKER_PASSWORD }} 2>/dev/null; then
+              docker push ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.new_version }}
+              docker push ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:latest
+              echo "Successfully pushed images to ${{ env.REGISTRY }}"
+            else
+              echo "Warning: Docker login failed with provided credentials"
+              echo "Images built locally but not pushed to registry"
+              echo "Manual push required:"
+              echo "  docker push ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.new_version }}"
+              echo "  docker push ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:latest"
+            fi
+          else
+            echo "Warning: DOCKER_LOGIN or DOCKER_PASSWORD secrets not configured"
+            echo "Images built locally but not pushed to registry"
+            echo "Manual push required:"
+            echo "  docker push ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.new_version }}"
+            echo "  docker push ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:latest"
+          fi
+
+      - name: Deploy to dev (placeholder)
+        if: steps.commit.outputs.committed == 'true'
+        run: |
+          echo "Deploying version ${{ steps.version.outputs.new_version }} to dev environment..."
+          # TODO: Add actual deployment steps
@@ -9,11 +9,12 @@ EuchreCamp is a Next.js 14+ application for managing Euchre tournaments and trac
 ### Key Technologies
 - **Next.js 14+** (App Router)
 - **TypeScript**
- **Prisma ORM** (SQLite)
+- **Prisma ORM** (SQLite/PostgreSQL)
 - **Tailwind CSS**
 - **Better Auth** (Authentication)
- **Vitest** (Unit Testing)
+- **Bun** (Package Manager & Test Runner)
 - **Playwright** (Acceptance Testing)
+- **Vitest** (Legacy - migrated to Bun test runner)

 ## Architecture Patterns

@@ -37,13 +38,39 @@ EuchreCamp is a Next.js 14+ application for managing Euchre tournaments and trac

 ## Common Tasks

+### Package Manager: Bun
+
+This project uses **Bun** as the package manager and test runner:
+
+```bash
+# Install dependencies
+bun install
+
+# Run development server
+bun run dev
+
+# Build the application
+bun run build
+
+# Run unit/component tests
+bun test
+
+# Run acceptance tests (Playwright)
+bun run test:acceptance
+
+# Run linting
+bun run lint
+```
+
+**Note**: E2E tests still use Playwright, as Bun's test runner doesn't support browser automation. Unit and component tests have been migrated to Bun's native test runner for faster execution.
+
 ### Admin User Creation

 To create an admin user, use the provided scripts:

 **Option 1: Using Better Auth API (Recommended)**
 ```bash
-node scripts/create-admin-via-api.js
+bun run scripts/create-admin-via-api.js
 ```
 This creates the admin user `david@dhg.lol` with password `adminadmin` using Better Auth's internal API.

@@ -109,10 +136,73 @@ npm run db:setup-postgres
 **Note:** The database provider is automatically detected by Better Auth and Prisma.

 ### Running Tests
+
+**Using just (recommended):**
+- **All tests**: `just test` (unit + acceptance with SQLite)
+- **Unit tests**: `just test-unit`
+- **Acceptance tests (SQLite)**: `just test-acceptance-sqlite`
+- **Acceptance tests (PostgreSQL)**: `just test-acceptance-postgres`
+- **PR validation**: `just pr-validate` (what runs on pull requests)
+
+**Using npm scripts:**
 - **Unit tests**: `npm run test`
 - **Acceptance tests**: `npm run test:acceptance`
 - **Specific test**: `npm run test:acceptance -- --grep "test name"`

+**CI-style acceptance tests with SQLite:**
+```bash
+DATABASE_PROVIDER=sqlite DATABASE_URL=file:./prisma/ci.db npm run test:acceptance
+```
+
+### CI Runner Image
+
+**Note:** The CI runner image approach has been deprecated for Gitea Actions workflows.
+
+The original attempt to use a pre-built CI runner image with pre-installed dependencies encountered fundamental issues with how Gitea Actions handles workspace mounting. When Gitea Actions runs a container job, it mounts the workspace at a specific path (e.g., `/workspace/david/euchre_camp`), which hides the container's `/app` directory where dependencies were installed.
+
+**Current Approach:**
+- Workflows use standard `node:20-alpine` or `mcr.microsoft.com/playwright` containers
+- Dependencies are installed via `npm ci` in each workflow run
+- This is the recommended approach for Gitea Actions
+
+**Why the CI image approach doesn't work:**
+1. Dockerfile.ci installs dependencies in `/app`
+2. Gitea Actions mounts workspace at `/workspace/david/euchre_camp`
+3. Workspace mount hides the `/app` directory
+4. Symlinks from `/app/node_modules` don't work because `/app` is hidden
+
+**Alternative for performance:**
+If CI performance becomes an issue, consider:
+- Using GitHub Actions cache for node_modules
+- Using a self-hosted runner with persistent workspace
+- Using the main Dockerfile's `test-runner` target for release workflows (which works because it builds a complete image)
+
+### CI/CD Pipeline
+The project uses Gitea Actions for continuous integration:
+
+**PR Workflow** (`.gitea/workflows/pr.yml`):
+- Runs on pull requests to main
+- Executes unit tests and acceptance tests with SQLite
+- Analyzes commits for semantic versioning
+- Comments suggested bump type on PRs
+
+**Test Workflow** (`.gitea/workflows/test.yml`):
+- Runs on all branch pushes
+- Executes unit tests for quick feedback
+- Skips auto-generated version bump commits
+
+**Release Workflow** (`.gitea/workflows/release.yml`):
+- Runs on main branch pushes
+- Determines version bump type
+- Bumps version and creates git tags
+- Builds Docker images and runs tests
+- Pushes to registry and deploys
+
+**Database Strategy**:
+- CI tests use SQLite (fast, no server required)
+- Production uses PostgreSQL
+- Switch with `DATABASE_PROVIDER` environment variable
+
 ## Key Files

 ### Configuration
@@ -170,6 +260,10 @@ npm run db:setup-postgres
 - Utilities: camelCase (e.g., `elo-utils.ts`)
 - Tests: `.test.ts` or `.test.tsx` suffix

+## File Organization
+
+See [docs/FILE_ORGANIZATION.md](docs/FILE_ORGANIZATION.md) for detailed file organization and structure.
+
 ## Resources

 - **Better Auth Docs**: https://better-auth.com/docs
@@ -0,0 +1,142 @@
+## [0.1.3] - 2026-04-01
+
+### Patch Changes
+
+- fix: skip release steps if no version bump commit was made
+- fix: improve error handling in getCommitsSinceLastTag
+- fix: add tag existence check in release workflow
+- fix: resolve release workflow version bump issues
+- ci-image-improvements (#18)
+- fix: version bumping and Docker registry authentication (#17)
+- fix: handle Docker registry authentication gracefully in release workflow
+- fix: run unit tests on branch commits, skip main branch
+- feat: add test workflow for every commit
+- trigger: release with test-capable image
+- feat: build test-capable image, run tests, then build production image
+- trigger: release workflow
+- fix: release workflow should not commit, only tag
+- trigger: manual workflow trigger for docker.notsosm.art
+- fix: update Docker build script to use docker.notsosm.art registry
+- fix: update workflow to use docker.notsosm.art registry
+- trigger: manual workflow trigger
+- fix: update workflow to use correct Docker registries
+- feat: add Gitea Actions release workflow
+- feat: add view match link to admin matches page
+
+## [0.1.2] - 2026-04-01
+
+### Patch Changes
+
+- fix: handle Docker registry authentication gracefully in release workflow
+- fix: run unit tests on branch commits, skip main branch
+- feat: add test workflow for every commit
+- trigger: release with test-capable image
+- feat: build test-capable image, run tests, then build production image
+- trigger: release workflow
+- fix: release workflow should not commit, only tag
+- trigger: manual workflow trigger for docker.notsosm.art
+- fix: update Docker build script to use docker.notsosm.art registry
+- fix: update workflow to use docker.notsosm.art registry
+- trigger: manual workflow trigger
+- fix: update workflow to use correct Docker registries
+- feat: add Gitea Actions release workflow
+- feat: add view match link to admin matches page
+
+## [0.1.1] - 2026-04-01
+
+### Patch Changes
+
+- Merge branch 'feat/database-test-safety' of ssh://git.notsosm.art/david/euchre_camp
+- fix: use ELO change instead of win rate for best partner calculation
+- fix: remove hardcoded passwords from docker-compose generation
+- fix: load .env.development in test setup files
+- fix: remove hardcoded database URLs and use environment variables
+- fix: set DATABASE_URL for acceptance tests
+- feat: add database test safety configuration
+- fix: allowTies not saved when editing tournaments (closes #6)
+- docs: add development database and testing documentation
+- feat: set up development database and test cleanup utilities
+- fix: improve availablePlayers query to handle undefined playerId
+- fix: handle empty playerId string in user edit API
+
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2026-03-31
+
+### Added
+
+- **Authentication System**: Complete Better Auth integration with session management
+- **Authorization (RBAC)**: Role-based access control with player, tournament_admin, club_admin, and site_admin roles
+- **Tournament Management**: Full CRUD operations with multiple formats (round-robin, single/double elimination, Swiss)
+- **Rating Systems**: Support for Elo, Glicko2, and OpenSkill rating calculations
+- **Admin Panel**: Comprehensive admin interface for managing players, tournaments, and matches
+- **Player Profiles**: Detailed player statistics with partnership analytics
+- **Match Recording**: CSV upload functionality for batch match entry
+- **Development Database**: Isolated development database for testing
+- **Test Cleanup System**: Automatic cleanup of test records
+- **Production Database Cleanup**: Tools to remove test data while preserving real data
+- **Semantic Versioning**: Git tagging and Docker image tagging system
+
+### Fixed
+
+- **Session Refresh**: Fixed navigation not updating immediately after login (closes #6)
+- **allowTies Save Bug**: Fixed "Allow Ties" checkbox not being saved when editing tournaments
+- **Next.js 16 Compatibility**: Fixed params Promise handling across all API routes and pages
+- **Match Diagram Positioning**: Fixed player positioning in match diagrams
+
+### Changed
+
+- **Database**: Migrated from SQLite to PostgreSQL with production-ready configuration
+- **Docker**: Updated image tagging to use versioned tags (e.g., v0.1.0, latest)
+- **Testing**: Improved test coverage with 103 passing unit tests
+- **Documentation**: Added comprehensive README with development setup instructions
+
+### Removed
+
+- N/A
+
+## [0.0.1] - Initial Development
+
+### Added
+
+- Basic database schema for Euchre tournament management
+- Initial Next.js application structure
+- Basic navigation and layout
+- Player rankings page
+
+---
+
+## Release Process
+
+This project follows semantic versioning (Semver):
+
+1. **Version Format**: `MAJOR.MINOR.PATCH`
+   - `MAJOR`: Breaking changes (API changes, database migrations requiring data migration)
+   - `MINOR`: New features (backward compatible)
+   - `PATCH`: Bug fixes, security updates
+
+2. **Pre-release Versions**: `MAJOR.MINOR.PATCH-alpha.N`, `MAJOR.MINOR.PATCH-beta.N`, `MAJOR.MINOR.PATCH-rc.N`
+
+3. **Creating a Release**:
+   ```bash
+   # Bump version
+   npm run version:patch  # or version:minor, version:major
+
+   # Create git tag
+   git tag -a v0.1.0 -m "Release v0.1.0"
+
+   # Push changes and tag
+   git push origin main
+   git push origin v0.1.0
+
+   # Build and push Docker images
+   npm run docker:build:push
+
+   # Create release in Gitea
+   tea release create v0.1.0 --title "Release v0.1.0" --note-file CHANGELOG.md
+   ```
@@ -1,9 +1,9 @@
 # Multi-stage build for EuchreCamp Next.js application

 # Stage 1: Builder
-FROM node:20-alpine AS builder
+FROM oven/bun:alpine AS builder

-# Install dependencies
+# Install dependencies (needed for native modules)
 RUN apk add --no-cache python3 make g++

 # Set working directory
@@ -13,21 +13,42 @@ WORKDIR /app
 COPY package*.json ./

 # Install dependencies (including dev dependencies for building)
-RUN npm ci
+RUN bun install

 # Copy source code
 COPY . .

 # Generate Prisma client (with dummy PostgreSQL DATABASE_URL for build-time generation)
 # Note: A dummy URL is used since the real database is not available during build
-RUN DATABASE_URL="postgresql://user:pass@localhost:5432/dummy" npx prisma generate
+RUN DATABASE_PROVIDER=postgresql DATABASE_URL="postgresql://user:pass@localhost:5432/dummy" bun x prisma generate

 # Build the application (with dummy DATABASE_URL for static page generation and git commit)
 ARG GIT_COMMIT=unknown
-RUN DATABASE_URL="postgresql://user:pass@localhost:5432/dummy" NEXT_PUBLIC_GIT_COMMIT=$GIT_COMMIT npm run build
+RUN DATABASE_PROVIDER=postgresql DATABASE_URL="postgresql://user:pass@localhost:5432/dummy" NEXT_PUBLIC_GIT_COMMIT=$GIT_COMMIT bun run build

-# Stage 2: Runner
-FROM node:20-alpine AS runner
+# Stage 2: Test runner (includes dev dependencies for testing)
+FROM oven/bun:alpine AS test-runner
+
+# Install dependencies
+RUN apk add --no-cache python3 make g++ git
+
+# Set working directory
+WORKDIR /app
+
+# Copy package files
+COPY package*.json ./
+
+# Install ALL dependencies (including dev dependencies for testing)
+RUN bun install
+
+# Copy source code
+COPY . .
+
+# Generate Prisma client
+RUN DATABASE_PROVIDER=postgresql DATABASE_URL="postgresql://user:pass@localhost:5432/dummy" bun x prisma generate
+
+# Stage 3: Production runner
+FROM oven/bun:alpine AS runner

 # Install dumb-init for proper signal handling
 RUN apk add --no-cache dumb-init
@@ -43,15 +64,15 @@ WORKDIR /app
 COPY --from=builder --chown=euchre:euchre /app/.next ./.next
 COPY --from=builder --chown=euchre:euchre /app/public ./public
 COPY --from=builder --chown=euchre:euchre /app/package.json ./package.json
-COPY --from=builder --chown=euchre:euchre /app/package-lock.json ./package-lock.json
+COPY --from=builder --chown=euchre:euchre /app/bun.lockb ./bun.lockb
 COPY --from=builder --chown=euchre:euchre /app/prisma ./prisma

 # Install only production dependencies
-RUN npm ci --omit=dev
+RUN bun install --production

 # Generate Prisma client
 # Note: We need to set DATABASE_URL even for generation because prisma.config.ts requires it
-RUN DATABASE_URL="postgresql://user:pass@localhost:5432/dummy" npx prisma generate
+RUN DATABASE_PROVIDER=postgresql DATABASE_URL="postgresql://user:pass@localhost:5432/dummy" bun x prisma generate

 # Switch to non-root user
 USER euchre
@@ -65,4 +86,4 @@ HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \

 # Start command
 ENTRYPOINT ["dumb-init", "--"]
-CMD ["npm", "start"]
+CMD ["bun", "run", "start"]
@@ -17,20 +17,29 @@ EuchreCamp is a full-stack web application built with Next.js 14+ and TypeScript

 - **Framework**: Next.js 14+ (App Router)
 - **Language**: TypeScript
- **Database**: Prisma ORM with SQLite
+- **Database**: Prisma ORM with SQLite (default) or PostgreSQL
 - **Styling**: Tailwind CSS
 - **Authentication**: Better Auth
 - **Form Handling**: React Hook Form + Zod validation
 - **CSV Parsing**: PapaParse
 - **Unit Testing**: Vitest
 - **Acceptance Testing**: Playwright
+- **CI/CD**: Gitea Actions with SQLite for CI tests

 ## Project Structure

 ```
 euchre_camp/
-├── src/
-│   ├── app/
+├── .gitea/workflows/     # CI/CD workflows (Gitea Actions)
+├── docs/                 # Documentation
+│   ├── deployment/       # Deployment guides
+│   └── planning/         # Planning documents
+├── prisma/               # Prisma schema and migrations
+├── public/               # Static assets
+├── scripts/              # Utility scripts
+│   └── python/           # Python scripts (legacy)
+├── src/                  # Source code
+│   ├── app/              # Next.js app directory
 │   │   ├── api/          # API routes
 │   │   ├── auth/         # Authentication pages
 │   │   ├── admin/        # Admin pages
@@ -39,16 +48,15 @@ euchre_camp/
 │   │   └── components/   # Shared components
 │   ├── lib/              # Utilities and configuration
 │   │   ├── auth.ts       # Better Auth configuration
-│   │   ├── prisma.ts     # Prisma client
+│   │   ├── prisma.ts     # Prisma client (SQLite/PostgreSQL)
 │   │   ├── permissions.ts # Authorization functions
 │   │   └── elo-utils.ts  # Elo calculation utilities
 │   └── __tests__/        # Vitest and Playwright tests
-├── prisma/               # Prisma schema and migrations
-├── docs/                 # Documentation
-├── scripts/              # Utility scripts
-└── public/               # Static assets
+└── ...                   # Configuration files in root
 ```

+See [docs/FILE_ORGANIZATION.md](docs/FILE_ORGANIZATION.md) for detailed file organization.
+
 ## Features Implemented

 ### Epic 1: Authentication & User Management
@@ -161,6 +169,46 @@ DATABASE_URL="postgresql://username:password@localhost:5432/euchre_camp"
 DATABASE_SHADOW_URL="postgresql://username:password@localhost:5432/euchre_camp_shadow"
 ```

+## Development Database
+
+For development and testing, use a separate development database to avoid conflicts with production data.
+
+**Setup Development Database:**
+
+```bash
+# Create and setup the development database
+npm run db:setup-dev
+
+# Reset the development database (drops and recreates)
+npm run db:reset-dev
+
+# Clean development database (drop and recreate with migrations)
+npm run db:setup-dev:clean
+```
+
+**Environment Configuration:**
+
+The development database uses `.env.development` which is automatically configured for:
+- Database: `euchre_camp_dev`
+- NODE_ENV: `development`
+
+**Testing with Development Database:**
+
+```bash
+# Run unit tests (uses test database automatically)
+npm run test
+
+# Run acceptance tests (uses development database)
+npm run test:acceptance
+```
+
+**Test Data Cleanup:**
+
+All tests automatically clean up their created records:
+- Global setup/teardown handles Playwright tests
+- Test utilities provide `cleanupTestRecords()` for manual cleanup
+- Tests use `beforeEach` and `afterEach` hooks for automatic cleanup
+
 ## Usage

 ### Creating a Tournament
@@ -202,6 +250,36 @@ Visit `/` to see:

 ## Development

+### Using just (recommended)
+The project includes a `justfile` with common development tasks:
+
+```bash
+# Show all available tasks
+just help
+
+# Development mode
+just dev
+
+# Run all tests (unit + acceptance with SQLite)
+just test
+
+# Run PR validation (what runs on pull requests)
+just pr-validate
+
+# Run CI pipeline locally
+just ci
+
+# Switch database provider
+just db-switch-sqlite
+just db-switch-postgres
+
+# Docker shortcuts
+just docker-up
+just docker-down
+just docker-logs
+```
+
+### Using npm scripts directly
 ```bash
 # Development mode
 npm run dev
@@ -215,6 +293,9 @@ npm run test

 # Run acceptance tests
 npm run test:acceptance
+
+# Run acceptance tests with SQLite (CI-style)
+DATABASE_PROVIDER=sqlite DATABASE_URL=file:./prisma/ci.db npm run test:acceptance
 ```

 ### Database Commands
@@ -273,6 +354,56 @@ User stories are organized into epics in `docs/USER_STORIES.md`:
 7. Mobile Responsiveness
 8. Data Management & Export

+## CI/CD Pipeline
+
+The application uses Gitea Actions for continuous integration and deployment:
+
+### Workflow Architecture
+1. **PR Workflow** (`.gitea/workflows/pr.yml`): Runs on pull requests
+   - Unit tests (fast feedback)
+   - Acceptance tests with SQLite database
+   - Semantic version bump analysis
+
+2. **Test Workflow** (`.gitea/workflows/test.yml`): Runs on all branch pushes
+   - Unit tests for quick feedback
+   - Skips auto-generated version bumps
+
+ 3. **Release Workflow** (`.gitea/workflows/release.yml`): Runs on main branch pushes
+    - Version bumping and tagging
+    - Docker image building and testing
+    - Registry push and deployment
+
+### CI Runner Image
+
+**Note:** The CI runner image approach has been deprecated for Gitea Actions workflows.
+
+The original attempt to use a pre-built CI runner image with pre-installed dependencies encountered fundamental issues with how Gitea Actions handles workspace mounting. When Gitea Actions runs a container job, it mounts the workspace at a specific path (e.g., `/workspace/david/euchre_camp`), which hides the container's `/app` directory where dependencies were installed.
+
+**Current Approach:**
+- Workflows use standard `node:20-alpine` or `mcr.microsoft.com/playwright` containers
+- Dependencies are installed via `npm ci` in each workflow run
+- This is the recommended approach for Gitea Actions
+
+**Why the CI image approach doesn't work:**
+1. Dockerfile.ci installs dependencies in `/app`
+2. Gitea Actions mounts workspace at `/workspace/david/euchre_camp`
+3. Workspace mount hides the `/app` directory
+4. Symlinks from `/app/node_modules` don't work because `/app` is hidden
+
+### Database Strategy for CI
+- **CI Tests**: SQLite database (fast, no server required)
+- **Production**: PostgreSQL (production-like environment)
+- **Configuration**: `DATABASE_PROVIDER` environment variable
+
+### Running CI Locally
+```bash
+# Run unit tests (same as CI)
+npm run test:run
+
+# Run acceptance tests with SQLite
+DATABASE_PROVIDER=sqlite DATABASE_URL=file:./prisma/ci.db npm run test:acceptance
+```
+
 ## Docker Deployment

 This application can be run using Docker and Docker Compose. See [DOCKER.md](DOCKER.md) for detailed instructions.
@@ -1,102 +0,0 @@
-# EuchreCamp - Todo List
-
-## Current Tasks
-
-### Completed ✅
- [x] Add `site_admin` role to database schema and permissions system
- [x] Add `isCasual` boolean field to Match model (already existed)
- [x] Update match upload API to support casual matches
- [x] Update match upload UI to include casual checkbox
- [x] Add tournament deletion API endpoint with delete/orphan options
- [x] Add delete tournament button and modal to tournament detail page
- [x] Run tests and verify implementation (84 tests passing)
- [x] Fix session issues with tournament admin access
- [x] Fix Elo recalculation error for player merge (delete elo snapshots before deleting players)
- [x] Add admin player management page
- [x] Add player name editing functionality in admin UI
- [x] Add admin panel links to navigation header
- [x] Add tournament update API endpoint (PUT /api/tournaments/[id])
- [x] Consolidate delete endpoint from admin API to main tournaments API
- [x] Update database schema to add variant scoring fields (targetScore, allowTies)
- [x] Fix tie handling logic in partnership stats (ties now correctly tracked)
- [x] Fix test files for normalizedName field in Player model
- [x] Fix auth.ts to include normalizedName in Player creation
- [x] Write TODO list to repository file
- [x] Auto-create tournament when uploading matches without selecting one
-
-### In Progress 🔄
- [ ] Update API routes to handle new variant scoring fields
- [ ] Update EditTournamentForm to add variant scoring controls
- [ ] Update MatchEditor to use tournament-specific target score
- [ ] Run tests and verify variant scoring implementation
-
-### Recently Completed ✅
- [x] Add OpenSkill rating system support (src/lib/openskill-utils.ts)
- [x] Add Glicko2 rating system support (src/lib/glicko2-utils.ts)
- [x] Reset database and run all migrations from scratch
- [x] Regenerate Prisma client with new rating models
- [x] Update match upload page to auto-create tournament if none selected
- [x] Update all admin scripts to use PrismaPg adapter and dotenv
- [x] Fix match diagram player positioning
- [x] Add CasaOS deployment configuration and documentation
- [x] Create migration to add rating system tables (elo_ratings, glicko2_ratings, open_skill_ratings)
- [x] Add tabbed rankings page to display Elo, OpenSkill, and Glicko2 ratings
-
-### Backlog 📋
- [ ] Add UI controls for variant scoring in tournament creation/edit
- [ ] Test variant tournament functionality end-to-end
- [ ] Add validation for tie scores based on tournament configuration
- [ ] Document variant tournament features
-
-## Recently Completed (Detailed)
-
-### Variant Euchre Scoring Support
- Added `targetScore` and `allowTies` fields to Event model
- Created database migration for new fields
- Fixed partnership stats tie handling (ties now increment neither wins nor losses)
- Updated Elo calculation functions to handle ties correctly (0.5 points for draw)
-
-### Tournament Deletion
- Consolidated delete endpoint to `/api/tournaments/[id]`
- Added options to delete matches or orphan them
- Updated DeleteTournamentButton to use consolidated endpoint
-
-### Player Management
- Added admin players page at `/admin/players`
- Added player name editing functionality via PATCH endpoint
- Added player merge functionality with automatic Elo recalculation
- Fixed foreign key constraint issues with elo_snapshots
-
-### Permissions
- Added `site_admin` role as highest privilege level
- Updated all permission functions to include site_admin support
- Fixed session cache issues by reading roles from database
-
-## Notes
- All 84 unit tests passing
- Database migrations applied successfully
- TypeScript compilation has pre-existing errors unrelated to our changes
-
-### Completed After Commit 1729dac
-
-#### Next.js 16 Breaking Change Fixes
- [x] Fixed `params.id` usage in all page components (must use `await params`)
- [x] Fixed `params.id` usage in all API routes (must use `await params`)
- [x] Updated client components to use `Promise<{ id: string }>` type
- [x] Added regression tests for Next.js 16 params Promise handling
- [x] Verified all 100 unit tests pass
-
-#### Files Updated:
- Player pages: `profile.tsx`, `schedule.tsx`
- Tournament pages: `page.tsx`, `results.tsx`, `edit.tsx`, `entry.tsx`
- API routes: `admin/players/[id]/route.ts`, `users/[id]/route.ts`, `users/[id]/role/route.ts`
- Tournament API routes: `[id]/route.ts`, `[id]/participants/route.ts`, `[id]/games/bulk/route.ts`
-
-#### Root Cause
-Next.js 16 requires `params` to be awaited in both server components and API routes:
- Before: `const { id } = params`
- After: `const { id } = await params`
-
-This was not caught by the unit test suite because:
- Unit tests test individual functions in isolation
- E2E tests (Playwright) would catch this but weren't run after the upgrade
@@ -0,0 +1,2 @@
+[test]
+preload = ["./src/__tests__/bun-setup.ts"]
@@ -7,15 +7,15 @@

 services:
  app:
-    image: dhg.lol:5000/euchre-camp:0.1.0
+    image: euchre-camp/euchre-camp:0.1.0.dev
    container_name: euchre-camp
    ports:
      - "51193:3000"
    environment:
      # Database Configuration (REQUIRED: Set via CasaOS environment variables)
      - DATABASE_PROVIDER=postgresql
-      - DATABASE_URL="postgresql://euchre_camp:LINGO5row_hiding@dhg.lol:5432/euchre_camp"
-      - DATABASE_SHADOW_URL="postgresql://euchre_camp:LINGO5row_hiding@dhg.lol:5432/euchre_camp_shadow"
+      - DATABASE_URL=${DATABASE_URL:-postgresql://euchre_camp:password@db:5432/euchre_camp}
+      - DATABASE_SHADOW_URL=${DATABASE_SHADOW_URL:-postgresql://euchre_camp:password@db:5432/euchre_camp_shadow}

      # Better Auth Configuration
      - BETTER_AUTH_SECRET=${BETTER_AUTH_SECRET:-change-this-secret-in-production}
@@ -28,7 +28,7 @@ services:
      - TRUSTED_ORIGINS=${TRUSTED_ORIGINS:-http://localhost:3000,http://127.0.0.1:3000}

      # Version tracking
-      - IMAGE_VERSION=0.1.0
+      - IMAGE_VERSION=0.1.0.dev

    volumes:
      # Persist uploaded files and static content
@@ -14,8 +14,8 @@ services:
    environment:
      # Database Configuration
      - DATABASE_PROVIDER=postgresql
-      - DATABASE_URL=postgresql://euchre_camp:password@db:5432/euchre_camp
-      - DATABASE_SHADOW_URL=postgresql://euchre_camp:password@db:5432/euchre_camp_shadow
+      - DATABASE_URL=${DATABASE_URL:-postgresql://euchre_camp:password@db:5432/euchre_camp}
+      - DATABASE_SHADOW_URL=${DATABASE_SHADOW_URL:-postgresql://euchre_camp:password@db:5432/euchre_camp_shadow}

      # Better Auth Configuration
      - BETTER_AUTH_SECRET=${BETTER_AUTH_SECRET:-dev-secret-change-in-production}
@@ -28,7 +28,7 @@ services:
      - TRUSTED_ORIGINS=${TRUSTED_ORIGINS:-http://localhost:3000,http://127.0.0.1:3000}

      # Version tracking
-      - IMAGE_VERSION=0.1.0
+      - IMAGE_VERSION=0.1.0.dev-dev

    volumes:
      # Mount source code for hot reload
@@ -3,15 +3,15 @@

 services:
  app:
-    image: dhg.lol:5000/euchre-camp:0.1.0
+    image: euchre-camp/euchre-camp:0.1.0.dev
    container_name: euchre-camp-app
    ports:
      - "3000:3000"
    environment:
      # Database Configuration
      - DATABASE_PROVIDER=postgresql
-      - DATABASE_URL=postgresql://euchre_camp:password@db:5432/euchre_camp
-      - DATABASE_SHADOW_URL=postgresql://euchre_camp:password@db:5432/euchre_camp_shadow
+      - DATABASE_URL=${DATABASE_URL:-postgresql://euchre_camp:password@db:5432/euchre_camp}
+      - DATABASE_SHADOW_URL=${DATABASE_SHADOW_URL:-postgresql://euchre_camp:password@db:5432/euchre_camp_shadow}

      # Better Auth Configuration
      - BETTER_AUTH_SECRET=${BETTER_AUTH_SECRET:-change-this-secret-in-production}
@@ -24,7 +24,7 @@ services:
      - TRUSTED_ORIGINS=${TRUSTED_ORIGINS:-http://localhost:3000,http://127.0.0.1:3000}

      # Version tracking
-      - IMAGE_VERSION=0.1.0
+      - IMAGE_VERSION=0.1.0.dev

    depends_on:
      - db
@@ -0,0 +1,125 @@
+# File Organization
+
+This document describes the organization of files in the EuchreCamp project.
+
+## Root Directory
+
+### Essential Files (Keep in Root)
+- `README.md` - Main project documentation
+- `AGENTS.md` - AI agent guide
+- `CHANGELOG.md` - Version changelog
+- `package.json` - Node.js dependencies and scripts
+- `package-lock.json` - Dependency lock file
+- `tsconfig.json` - TypeScript configuration
+- `next.config.js` - Next.js configuration
+- `.gitignore` - Git ignore file
+- `Dockerfile` - Docker build configuration
+- `justfile` - Development task automation
+
+### Configuration Files (Keep in Root)
+- `.eslintrc.json` - ESLint configuration
+- `postcss.config.mjs` - PostCSS configuration
+- `playwright.config.ts` - Playwright test configuration
+- `vitest.config.mts` - Vitest configuration
+- `vitest.setup.ts` - Vitest setup
+- `.dockerignore` - Docker ignore file
+- `mise.toml` - Mise version manager config
+
+### Docker Files (Keep in Root)
+- `docker-compose.yml` - Main Docker Compose
+- `docker-compose.dev.yml` - Development Docker Compose
+- `docker-compose.override.yml` - Override for dev
+- `docker-compose.casaos.yml` - CasaOS specific
+
+### Environment Files (Keep in Root, Gitignored)
+- `.env` - Environment variables
+- `.env.development` - Development environment
+
+## Organized Directories
+
+### `.gitea/` - Gitea Actions Workflows
+- `workflows/pr.yml` - Pull request workflow (unit + acceptance tests)
+- `workflows/test.yml` - Test workflow (unit tests on branch pushes)
+- `workflows/release.yml` - Release workflow (version bump + Docker build)
+- `WORKFLOW_ARCHITECTURE.md` - Workflow architecture documentation
+
+### `docs/` - Documentation
+- `deployment/` - Deployment documentation
+  - `CASAOS_DEPLOYMENT.md` - CasaOS deployment guide
+  - `DOCKER.md` - Docker deployment instructions
+- `TODO.md` - Project TODO list (in docs root for visibility)
+- `USER_STORIES.md` - User stories organized by epic
+- Other documentation files (design, implementation, testing, etc.)
+
+### `scripts/` - Utility Scripts
+- `python/` - Python scripts (legacy/old functionality)
+  - `generate_games.py` - Generate sample games
+  - `update_partnership_stats.py` - Update partnership stats
+  - `update_player_stats.py` - Update player stats
+- `bump-version.js` - Version bumping script
+- `build-and-push-docker.js` - Docker build and push script
+- `switch-database.js` - Database provider switching
+- `create-admin-via-api.js` - Admin user creation via API
+- `create-admin-better-auth.js` - Admin user creation via database
+- `list-users.js` - List all users
+- `update-admin-password.js` - Update admin password
+- `seed.js` - Database seeding
+- And other Node.js scripts...
+
+### `src/` - Source Code
+- `app/` - Next.js app directory
+  - `api/` - API routes
+  - `auth/` - Authentication pages
+  - `admin/` - Admin pages
+  - `players/` - Player pages
+  - `rankings/` - Rankings page
+  - `components/` - Shared components
+- `lib/` - Utilities and configuration
+  - `auth.ts` - Better Auth configuration
+  - `prisma.ts` - Prisma client (supports SQLite and PostgreSQL)
+  - `permissions.ts` - Authorization functions
+  - `elo-utils.ts` - Elo calculation utilities
+- `__tests__/` - Vitest and Playwright tests
+  - `unit/` - Unit tests
+  - `e2e/` - End-to-end acceptance tests
+
+### `prisma/` - Database
+- `schema.prisma` - Prisma schema
+- `migrations/` - Database migrations
+- `dev.db` - SQLite development database (if using SQLite)
+
+### `public/` - Static Assets
+- Images, fonts, and other static files
+
+### `playwright/` - Playwright Test Data
+- Authentication state files
+
+## Generated Directories (Gitignored)
+- `.next/` - Next.js build output
+- `node_modules/` - Node.js dependencies
+- `playwright-report/` - Playwright test reports
+- `test-results/` - Test results
+
+## File Organization Principles
+
+1. **Keep standard files in root**: package.json, tsconfig.json, etc.
+2. **Organize by function**: Group related files in directories
+3. **Separate generated from source**: Keep build outputs and dependencies separate
+4. **Document organization**: Use this file to explain structure
+5. **Follow conventions**: Use standard naming and organization patterns
+
+## CI/CD File Organization
+
+### Workflows
+- `.gitea/workflows/pr.yml` - Pull request validation
+- `.gitea/workflows/test.yml` - Branch testing
+- `.gitea/workflows/release.yml` - Main branch release
+
+### Database Strategy
+- **CI/Testing**: SQLite (fast, no server)
+- **Production**: PostgreSQL (production-like)
+
+### Testing
+- Unit tests: `npm run test:run`
+- Acceptance tests (SQLite): `DATABASE_PROVIDER=sqlite npm run test:acceptance`
+- Acceptance tests (PostgreSQL): `npm run test:acceptance` (with Docker)
@@ -1,134 +1,114 @@
-# EuchreCamp - Project Todo List
+# EuchreCamp - Todo List

-## Completed Features
+## Current Tasks

-### Backend
- [x] Database schema for matches, players, teams, events
- [x] Elo rating calculator and job
- [x] Partnership tracking and analytics
- [x] Tournament generator (round-robin, single elim, double elim, Swiss)
- [x] ROM relations and repositories
- [x] Acceptance test suite (8 tests passing)
+### Completed ✅
+- [x] Add `site_admin` role to database schema and permissions system
+- [x] Add `isCasual` boolean field to Match model (already existed)
+- [x] Update match upload API to support casual matches
+- [x] Update match upload UI to include casual checkbox
+- [x] Add tournament deletion API endpoint with delete/orphan options
+- [x] Add delete tournament button and modal to tournament detail page
+- [x] Run tests and verify implementation (84 tests passing)
+- [x] Fix session issues with tournament admin access
+- [x] Fix Elo recalculation error for player merge (delete elo snapshots before deleting players)
+- [x] Add admin player management page
+- [x] Add player name editing functionality in admin UI
+- [x] Add admin panel links to navigation header
+- [x] Add tournament update API endpoint (PUT /api/tournaments/[id])
+- [x] Consolidate delete endpoint from admin API to main tournaments API
+- [x] Update database schema to add variant scoring fields (targetScore, allowTies)
+- [x] Fix tie handling logic in partnership stats (ties now correctly tracked)
+- [x] Fix test files for normalizedName field in Player model
+- [x] Fix auth.ts to include normalizedName in Player creation
+- [x] Write TODO list to repository file
+- [x] Auto-create tournament when uploading matches without selecting one

-### Frontend
- [x] Basic player rankings page
- [x] Match entry form
+### In Progress 🔄
+- [ ] Update CI/CD workflows to use Bun (PR, test, release)
+- [ ] Update Dockerfile to use Bun Alpine image
+- [ ] Verify release workflow with Bun
+- [ ] Update API routes to handle new variant scoring fields
+- [ ] Update EditTournamentForm to add variant scoring controls
+- [ ] Update MatchEditor to use tournament-specific target score
+- [ ] Run tests and verify variant scoring implementation

-## In Progress - UI Development
+### Recently Completed ✅
+- [x] Fix Prisma build error in CI pipeline (Docker build failure due to missing DATABASE_URL validation)
+- [x] Add defensive checks to src/lib/prisma.ts to prevent build failures
+- [x] Migrate from npm to Bun package manager
+- [x] Migrate unit tests (Vitest → Bun test runner)
+- [x] Migrate component tests (Vitest → Bun test runner)
+- [x] Configure Bun with DOM environment for React Testing Library
+- [x] Keep Playwright for E2E tests (hybrid approach)

-### Completed
- [x] Navigation layout (Next.js components)
- [x] UI Design document (UI_DESIGN.md)
- [x] Player Profile page (Next.js)
- [x] Basic CSS styling (Tailwind CSS)
- [x] Player Schedule page (Next.js)
- [x] Route for player schedule
+### Recently Completed ✅
+- [x] Add OpenSkill rating system support (src/lib/openskill-utils.ts)
+- [x] Add Glicko2 rating system support (src/lib/glicko2-utils.ts)
+- [x] Reset database and run all migrations from scratch
+- [x] Regenerate Prisma client with new rating models
+- [x] Update match upload page to auto-create tournament if none selected
+- [x] Update all admin scripts to use PrismaPg adapter and dotenv
+- [x] Fix match diagram player positioning
+- [x] Add CasaOS deployment configuration and documentation
+- [x] Create migration to add rating system tables (elo_ratings, glicko2_ratings, open_skill_ratings)
+- [x] Add tabbed rankings page to display Elo, OpenSkill, and Glicko2 ratings

-### View Types to Implement
- [ ] Tournament Admin View (Phase 2-3)
-  - Create/manage tournaments
-  - Set up brackets and matchups
-  - Record match results
-  - View tournament standings
+### Backlog 📋
+- [ ] Add UI controls for variant scoring in tournament creation/edit
+- [ ] Test variant tournament functionality end-to-end
+- [ ] Add validation for tie scores based on tournament configuration
+- [ ] Document variant tournament features

- [ ] Club Admin View (Superuser) (Phase 3-4)
-  - Manage all players
-  - View club-wide statistics
-  - Configure club settings
-  - Manage tournaments
+## Recently Completed (Detailed)

- [ ] Player Profile View (Phase 1-2)
-  - Display player info and Elo rating
-  - Show partnership analytics
-  - Display match history
-  - Tournament participation
-  - Enhance existing template
+### Variant Euchre Scoring Support
+- Added `targetScore` and `allowTies` fields to Event model
+- Created database migration for new fields
+- Fixed partnership stats tie handling (ties now increment neither wins nor losses)
+- Updated Elo calculation functions to handle ties correctly (0.5 points for draw)

- [ ] Player Tournament Schedule View (Phase 4)
-  - Show upcoming matches
-  - Display tournament brackets
-  - Record personal match results
+### Tournament Deletion
+- Consolidated delete endpoint to `/api/tournaments/[id]`
+- Added options to delete matches or orphan them
+- Updated DeleteTournamentButton to use consolidated endpoint

-### UI Components Needed
- [x] Navigation system (role-based) - Started
- [ ] Dashboard layouts
- [ ] Forms for data entry
- [ ] Tables for displaying data
- [ ] Charts for statistics
- [ ] Bracket visualization
+### Player Management
+- Added admin players page at `/admin/players`
+- Added player name editing functionality via PATCH endpoint
+- Added player merge functionality with automatic Elo recalculation
+- Fixed foreign key constraint issues with elo_snapshots

-### Implementation Phases
- [x] Phase 1: Navigation & Layout
- [x] Phase 2: Player Profile Enhancements
- [x] Phase 3: Tournament Admin View
- [x] Phase 4: Club Admin View
- [x] Phase 5: Player Schedule View
- [ ] Phase 6: Authentication & Authorization
- [x] Phase 7: Polish & Testing
+### Permissions
+- Added `site_admin` role as highest privilege level
+- Updated all permission functions to include site_admin support
+- Fixed session cache issues by reading roles from database

-## Future Enhancements
+## Notes
+- All 84 unit tests passing
+- Database migrations applied successfully
+- TypeScript compilation has pre-existing errors unrelated to our changes

-### Features
- [ ] Real-time match updates (WebSockets)
- [ ] Mobile-responsive design improvements
- [ ] Email notifications
- [ ] Import/Export functionality
- [ ] API for third-party integrations
- [ ] Advanced analytics charts
+### Completed After Commit 1729dac

-### Technical
- [ ] Performance optimization
- [ ] Caching strategy
- [ ] Security hardening
- [ ] Deployment pipeline
- [ ] CI/CD setup
+#### Next.js 16 Breaking Change Fixes
+- [x] Fixed `params.id` usage in all page components (must use `await params`)
+- [x] Fixed `params.id` usage in all API routes (must use `await params`)
+- [x] Updated client components to use `Promise<{ id: string }>` type
+- [x] Added regression tests for Next.js 16 params Promise handling
+- [x] Verified all 100 unit tests pass

-## AAA System (Authentication, Authorization, Accounting) - Next.js Implementation
+#### Files Updated:
+- Player pages: `profile.tsx`, `schedule.tsx`
+- Tournament pages: `page.tsx`, `results.tsx`, `edit.tsx`, `entry.tsx`
+- API routes: `admin/players/[id]/route.ts`, `users/[id]/route.ts`, `users/[id]/role/route.ts`
+- Tournament API routes: `[id]/route.ts`, `[id]/participants/route.ts`, `[id]/games/bulk/route.ts`

-### Authentication (Better Auth + Prisma)
- [x] Set up Better Auth with Prisma
- [x] Create users table schema
- [x] Build login page (`/auth/login`)
- [x] Build registration page (`/auth/register`)
- [x] Implement session management with Better Auth
- [x] Add authentication middleware
- [ ] Password reset functionality
- [ ] Email confirmation system
- [ ] OAuth providers (optional)
+#### Root Cause
+Next.js 16 requires `params` to be awaited in both server components and API routes:
+- Before: `const { id } = params`
+- After: `const { id } = await params`

-### Authorization (RBAC)
- [x] Define roles in Prisma schema (PLAYER, TOURNAMENT_ADMIN, CLUB_ADMIN)
- [x] Implement authorization helpers
- [x] Add authorization to admin dashboard
- [x] Add authorization to player management
- [x] Add authorization to tournament management
- [x] Add 5-minute match edit window (player role)
- [ ] Add role assignment UI for club admins
- [ ] Add permission checks to all API routes
-
-### Accounting (Activity Logging)
- [ ] Create activity logging system (Prisma model)
- [ ] Track authentication events
- [ ] Track tournament management events
- [ ] Track match recording events
- [ ] Build audit reports UI
-
-### Security
- [x] Rate limiting (Better Auth built-in)
- [ ] IP-based lockout
- [x] Secure cookie settings (Better Auth)
- [x] CSRF protection (Next.js built-in)
- [ ] Security headers
- [ ] Session fixation prevention
-
-## Known Issues
- [ ] Database IDs not resetting between tests (workaround: query by round_number)
- [ ] Need to clean up debug output from acceptance tests
- [ ] Password reset flow not yet implemented
-
-## Next Steps
-1. Design UI mockups for each view type
-2. Implement navigation system
-3. Build out Tournament Admin view
-4. Add role-based access control
-5. Create reusable UI components
+This was not caught by the unit test suite because:
+- Unit tests test individual functions in isolation
+- E2E tests (Playwright) would catch this but weren't run after the upgrade
@@ -9,8 +9,8 @@ set positional-arguments
 # Project name
 PROJECT := "euchre-camp"

-# Docker registry (CasaOS local registry)
-REGISTRY := "euchre-camp"  # Update to your registry host if needed
+# Docker registry
+REGISTRY := "docker.notsosm.art"
 IMAGE_TAG := "latest"

 # Get git commit hash (short version)
@@ -22,6 +22,8 @@ IMAGE_TAG_COMMIT := `git rev-parse --short HEAD`
 # --- Variables ---
 # Database
 DB_CONTAINER := "euchre-camp-postgres"
+DATABASE_PROVIDER := env_var_or_default("DATABASE_PROVIDER", "sqlite")
+DATABASE_URL := env_var_or_default("DATABASE_URL", "file:./prisma/dev.db")

 # --- Setup & Installation ---

@@ -54,15 +56,24 @@ format:

 # --- Testing ---

-# Run all tests (unit + acceptance)
-test: test-unit test-acceptance
+# Run all tests (unit + acceptance with SQLite)
+# Note: Uses Docker containers for consistent environment
+test: test-unit test-acceptance-sqlite
+
+# Run all tests with PostgreSQL (Docker)
+test-pg: test-unit test-acceptance-postgres

 # Run unit tests (Vitest)
 test-unit:
    npm run test:run

-# Run acceptance tests (Playwright)
-test-acceptance:
+# Run acceptance tests with SQLite (fast, no Docker needed)
+test-acceptance-sqlite:
+    @echo "Running acceptance tests with SQLite..."
+    DATABASE_PROVIDER=sqlite DATABASE_URL=file:./prisma/ci.db BETTER_AUTH_SECRET=test-secret-key npm run test:acceptance
+
+# Run acceptance tests with PostgreSQL (Docker)
+test-acceptance-postgres:
    @echo "Starting Docker containers for acceptance tests..."
    docker compose up -d
    @echo "Waiting for services to be ready..."
@@ -80,6 +91,13 @@ migrate:
 seed:
    npm run db:seed

+# Switch database provider
+db-switch-sqlite:
+    npm run db:switch sqlite
+
+db-switch-postgres:
+    npm run db:switch postgresql
+
 # --- Docker ---

 # Build the Docker image (standard build)
@@ -143,9 +161,18 @@ docker-push: docker-build-full
 # --- CI/CD Pipeline Simulation ---

 # Run full CI pipeline locally (lint, test, build, push)
-ci: lint typecheck test-unit docker-build
+# Matches the Gitea Actions workflow
+ci: lint typecheck test-unit test-acceptance-sqlite docker-build
    @echo "CI Pipeline completed successfully!"

+# PR validation (what runs on pull requests)
+pr-validate: lint typecheck test-unit test-acceptance-sqlite
+    @echo "PR validation completed successfully!"
+
+# Run CI with PostgreSQL (for release workflow simulation)
+ci-postgres: lint typecheck test-unit test-acceptance-postgres docker-build
+    @echo "CI Pipeline with PostgreSQL completed successfully!"
+
 # --- Utilities ---

 # Show help information
@@ -158,3 +185,74 @@ clean:
    rm -rf node_modules .next dist
    @echo "Cleaning Docker artifacts..."
    docker system prune -f
+
+# Generate Prisma client
+prisma-generate:
+    npx prisma generate
+
+# Reset development database
+db-reset-dev:
+    npm run db:reset-dev
+
+# Setup development database
+db-setup-dev:
+    npm run db:setup-dev
+
+# Clean production database (remove test records)
+db-clean-prod:
+    npm run db:cleanup-prod
+
+# Check production database for test records
+db-check-prod:
+    npm run db:check-prod
+
+# Create admin user
+admin-create:
+    node scripts/create-admin-via-api.js
+
+# List all users
+users-list:
+    node scripts/list-users.js
+
+# Update admin password
+admin-update-password:
+    node scripts/update-admin-password.js
+
+# Bump version
+version-bump-patch:
+    npm run version:patch
+
+version-bump-minor:
+    npm run version:minor
+
+version-bump-major:
+    npm run version:major
+
+# Docker Compose shortcuts
+docker-up:
+    npm run docker:up
+
+docker-down:
+    npm run docker:down
+
+docker-logs:
+    npm run docker:logs
+
+# View workflow status
+workflow-status:
+    @echo "Current workflows in .gitea/workflows/:"
+    ls -la .gitea/workflows/
+    @echo ""
+    @echo "PR Workflow: Runs unit + acceptance tests on pull requests"
+    @echo "Test Workflow: Runs unit tests on all branch pushes"
+    @echo "Release Workflow: Runs on main branch pushes (version bump + Docker build)"
+    @echo ""
+    @echo "Note: CI image approach deprecated due to Gitea Actions workspace mounting"
+
+# Check current database provider
+db-status:
+    @echo "Database Provider: ${DATABASE_PROVIDER}"
+    @echo "Database URL: ${DATABASE_URL}"
+    @echo ""
+    @echo "Current schema.prisma provider:"
+    grep -A 2 "datasource db" prisma/schema.prisma | head -3
@@ -1,4 +1,5 @@
 [tools]
+bun = "latest"
 docker-compose = "latest"
 just = "latest"
 node = "latest"
@@ -1,32 +1,38 @@
 {
  "name": "euchre_camp",
-  "version": "0.1.0",
+  "version": "0.1.3",
  "private": true,
  "scripts": {
    "dev": "NEXT_PUBLIC_GIT_COMMIT=$(git rev-parse --short HEAD) next dev",
    "build": "next build",
    "start": "next start",
-    "lint": "eslint",
-    "test": "vitest",
-    "test:run": "vitest run",
-    "test:acceptance": "playwright test src/__tests__/e2e/",
-    "test:acceptance:headed": "playwright test src/__tests__/e2e/ --headed",
-    "db:switch": "node scripts/switch-database.js",
-    "db:setup-postgres": "node scripts/setup-postgres.js",
-    "db:seed": "node scripts/seed.js",
+    "lint": "bun run eslint",
+    "test": "bun test",
+    "test:run": "bun test",
+    "test:acceptance": "bun x playwright test src/__tests__/e2e/",
+    "test:acceptance:headed": "bun x playwright test src/__tests__/e2e/ --headed",
+    "db:switch": "bun run scripts/switch-database.js",
+    "db:setup-postgres": "bun run scripts/setup-postgres.js",
+    "db:setup-dev": "bun run scripts/setup-postgres.js",
+    "db:setup-dev:clean": "bun run scripts/setup-postgres.js --drop",
+    "db:reset-dev": "bun run scripts/reset-dev-db.js",
+    "db:use-dev": "bun run scripts/use-dev-db.js",
+    "db:cleanup-prod": "bun run scripts/cleanup-prod-db.js",
+    "db:check-prod": "bun run scripts/check-test-records.js",
+    "db:seed": "bun run scripts/seed.js",
    "docker:up": "docker-compose up -d",
    "docker:down": "docker-compose down",
    "docker:logs": "docker-compose logs -f",
    "docker:build": "docker-compose build",
    "docker:shell": "docker exec -it euchre-camp-app sh",
-    "version": "node scripts/bump-version.js",
-    "set-version": "node scripts/set-version.js",
-    "version:patch": "node scripts/bump-version.js patch",
-    "version:minor": "node scripts/bump-version.js minor",
-    "version:major": "node scripts/bump-version.js major",
-    "docker:build:push": "node scripts/build-and-push-docker.js",
-    "docker:compose:generate": "node scripts/generate-docker-compose.js",
-    "release": "npm run version:patch && npm run docker:compose:generate && npm run docker:build:push"
+    "version": "bun run scripts/bump-version.js",
+    "set-version": "bun run scripts/set-version.js",
+    "version:patch": "bun run scripts/bump-version.js patch",
+    "version:minor": "bun run scripts/bump-version.js minor",
+    "version:major": "bun run scripts/bump-version.js major",
+    "docker:build:push": "bun run scripts/build-and-push-docker.js",
+    "docker:compose:generate": "bun run scripts/generate-docker-compose.js",
+    "release": "bun run version:patch && bun run docker:compose:generate && bun run docker:build:push"
  },
  "dependencies": {
    "@hookform/resolvers": "^5.2.2",
@@ -14,7 +14,7 @@ const fs = require('fs');
 const path = require('path');

 // Configuration
-const REGISTRY = 'dhg.lol:5000';
+const REGISTRY = 'docker.notsosm.art';
 const IMAGE_NAME = 'euchre-camp';
 const FULL_IMAGE_NAME = `${REGISTRY}/${IMAGE_NAME}`;

@@ -17,6 +17,7 @@ const path = require('path');
 // Parse command line arguments
 const args = process.argv.slice(2);
 const forcedVersion = args[0]; // e.g., "0.2.0" or "patch/minor/major"
+const skipConfirm = args.includes('--yes') || args.includes('-y'); // Skip confirmation prompt

 // Paths
 const packageJsonPath = path.join(__dirname, '..', 'package.json');
@@ -47,14 +48,22 @@ function getCommitsSinceLastTag() {

    if (!latestTag) {
      // No tags yet, get all commits
-      return execSync('git log --oneline --format=%s', { encoding: 'utf8' }).trim().split('\n');
+      const commits = execSync('git log --oneline --format=%s', { encoding: 'utf8' }).trim();
+      return commits ? commits.split('\n') : [];
    }

    const commits = execSync(`git log ${latestTag}..HEAD --oneline --format=%s`, { encoding: 'utf8' }).trim();
    return commits ? commits.split('\n') : [];
  } catch (error) {
    // If no commits since tag or other error, get recent commits
-    return execSync('git log --oneline --format=%s -n 20', { encoding: 'utf8' }).trim().split('\n');
+    try {
+      const commits = execSync('git log --oneline --format=%s -n 20', { encoding: 'utf8' }).trim();
+      return commits ? commits.split('\n') : [];
+    } catch (innerError) {
+      // If all git log attempts fail, return empty array
+      console.warn('Warning: Could not retrieve commit history, defaulting to patch version');
+      return [];
+    }
  }
 }

@@ -174,37 +183,47 @@ function main() {
    console.log(`New version: ${currentVersion} → ${newVersion}`);
  }

-  // Confirm with user
-  const readline = require('readline');
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
+  // Confirm with user (or skip if --yes flag is set)
+  if (skipConfirm) {
+    // Update package.json
+    updatePackageJson(newVersion);

-  rl.question(`\nApply version ${newVersion}? (y/N) `, (answer) => {
-    if (answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes') {
-      // Update package.json
-      updatePackageJson(newVersion);
-
-      // Update changelog
-      if (bumpType !== 'custom') {
-        const commits = getCommitsSinceLastTag();
-        updateChangelog(newVersion, commits, bumpType);
-      }
-
-      console.log(`\n✅ Version bumped to ${newVersion}`);
-      console.log(`\nNext steps:`);
-      console.log(`  1. Review changes: git diff`);
-      console.log(`  2. Commit changes: git commit -am "chore: bump version to v${newVersion}"`);
-      console.log(`  3. Create tag: git tag -a v${newVersion} -m "Release v${newVersion}"`);
-      console.log(`  4. Push changes: git push origin main`);
-      console.log(`  5. Push tag: git push origin v${newVersion}`);
-    } else {
-      console.log('❌ Version bump cancelled');
+    // Update changelog
+    if (bumpType !== 'custom') {
+      const commits = getCommitsSinceLastTag();
+      updateChangelog(newVersion, commits, bumpType);
    }

-    rl.close();
-  });
+    console.log(`\n✅ Version bumped to ${newVersion}`);
+    process.exit(0);
+  } else {
+    const readline = require('readline');
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    rl.question(`\nApply version ${newVersion}? (y/N) `, (answer) => {
+      if (answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes') {
+        // Update package.json
+        updatePackageJson(newVersion);
+
+        // Update changelog
+        if (bumpType !== 'custom') {
+          const commits = getCommitsSinceLastTag();
+          updateChangelog(newVersion, commits, bumpType);
+        }
+
+        console.log(`\n✅ Version bumped to ${newVersion}`);
+        process.exit(0);
+      } else {
+        console.log('❌ Version bump cancelled');
+        process.exit(1);
+      }
+
+      rl.close();
+    });
+  }
 }

 // Run main function
@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+
+/**
+ * Check for test records in production database (read-only)
+ * Shows what would be deleted without making any changes
+ */
+
+const { execSync } = require('child_process');
+
+// Database connection string - must be explicitly set via environment variable
+const DB_URL = process.env.PROD_DATABASE_URL || process.env.DATABASE_URL;
+
+// Check if database URL is set
+if (!DB_URL) {
+  console.error('❌ No database URL set');
+  console.error('Please set PROD_DATABASE_URL or DATABASE_URL environment variable');
+  console.error('For production: PROD_DATABASE_URL="postgresql://user:pass@host:port/dbname"');
+  process.exit(1);
+}
+
+// Validate that we're not accidentally using dev database
+if (DB_URL.includes('_dev') || DB_URL.includes('_dev_')) {
+  console.error('❌ ERROR: This script should not be used with the development database!');
+  console.error('   Current DATABASE_URL:', DB_URL);
+  console.error('   Please set PROD_DATABASE_URL for production database operations.');
+  process.exit(1);
+}
+
+// Helper to run SQL and log results
+function runSQL(sql, description) {
+  console.log(`\n🔍 ${description}...`);
+  try {
+    const result = execSync(`psql "${DB_URL}" -c "${sql}"`, { encoding: 'utf8' });
+    console.log(result);
+    return true;
+  } catch (error) {
+    console.error(`❌ Error: ${error.message}`);
+    return false;
+  }
+}
+
+// Helper to count records matching pattern
+function countRecords(table, column, pattern) {
+  const sql = `SELECT COUNT(*) FROM ${table} WHERE ${column} LIKE '${pattern}';`;
+  try {
+    const result = execSync(`psql "${DB_URL}" -c "${sql}" -t`, { encoding: 'utf8' }).trim();
+    return parseInt(result);
+  } catch (error) {
+    return 0;
+  }
+}
+
+console.log('🔍 Checking test records in production database');
+console.log('=============================================\n');
+
+// Count test players
+const testPlayerCount = countRecords('players', 'name', '%Test%') +
+                       countRecords('players', 'name', '%Setup%') +
+                       countRecords('players', 'name', '%Home Test%') +
+                       countRecords('players', 'name', '%Home Match Player%') +
+                       countRecords('players', 'name', '%Admin User%');
+console.log(`Test players found: ${testPlayerCount}`);
+
+// Count test tournaments
+const testEventCount = countRecords('events', 'name', '%Test%') +
+                      countRecords('events', 'name', '%Setup%') +
+                      countRecords('events', 'name', '%Recent%');
+console.log(`Test tournaments found: ${testEventCount}`);
+
+// Count test users
+const testUserCount = countRecords('users', 'email', '%test%') +
+                     countRecords('users', 'email', '%setup%');
+console.log(`Test users found: ${testUserCount}`);
+
+// Show test players
+runSQL(`
+  SELECT id, name 
+  FROM players 
+  WHERE name LIKE '%Test%' OR name LIKE '%Setup%' OR name LIKE '%Home Test%' OR name LIKE '%Home Match Player%' OR name LIKE '%Admin User%'
+  ORDER BY name;
+`, 'Test players list');
+
+// Show test events
+runSQL(`
+  SELECT id, name 
+  FROM events 
+  WHERE name LIKE '%Test%' OR name LIKE '%Setup%' OR name LIKE '%Recent%'
+  ORDER BY name;
+`, 'Test events list');
+
+// Show test users
+runSQL(`
+  SELECT id, email, name 
+  FROM users 
+  WHERE email LIKE '%test%' OR email LIKE '%setup%'
+  ORDER BY email;
+`, 'Test users list');
+
+// Check which test players have matches (simplified query)
+runSQL(`
+  SELECT p.id, p.name 
+  FROM players p 
+  WHERE (p.name LIKE '%Test%' OR p.name LIKE '%Setup%' OR p.name LIKE '%Home Test%' OR p.name LIKE '%Home Match Player%' OR p.name LIKE '%Admin User%')
+  ORDER BY p.name;
+`, 'Test players (will be deleted)');
+
+// Check which test events exist
+runSQL(`
+  SELECT e.id, e.name 
+  FROM events e 
+  WHERE (e.name LIKE '%Test%' OR e.name LIKE '%Setup%' OR e.name LIKE '%Recent%')
+  ORDER BY e.name;
+`, 'Test events (will be deleted with matches via cascade)');
+
+console.log('\n✅ Check complete!');
+console.log('\n💡 Summary:');
+console.log('   - Test tournaments (with matches) can be deleted');
+console.log('   - Test players can be deleted');
+console.log('   - Test users without player associations can be deleted');
@@ -0,0 +1,147 @@
+#!/usr/bin/env node
+
+/**
+ * Clean up production database - remove test records only
+ * 
+ * WARNING: This script modifies the production database.
+ * It only removes records that match test patterns.
+ * It preserves actual player data, matches, and tournaments.
+ */
+
+const { execSync } = require('child_process');
+
+// Database connection string - must be explicitly set via environment variable
+const DB_URL = process.env.PROD_DATABASE_URL || process.env.DATABASE_URL;
+
+// Check if database URL is set
+if (!DB_URL) {
+  console.error('❌ No database URL set');
+  console.error('Please set PROD_DATABASE_URL or DATABASE_URL environment variable');
+  console.error('For production: PROD_DATABASE_URL="postgresql://user:pass@host:port/dbname"');
+  process.exit(1);
+}
+
+// Validate that we're not accidentally using dev database
+if (DB_URL.includes('_dev') || DB_URL.includes('_dev_')) {
+  console.error('❌ ERROR: This script should not be used with the development database!');
+  console.error('   Current DATABASE_URL:', DB_URL);
+  console.error('   Please set PROD_DATABASE_URL for production database operations.');
+  process.exit(1);
+}
+
+// Helper to run SQL and log results
+function runSQL(sql, description) {
+  console.log(`\n🔍 ${description}...`);
+  try {
+    const result = execSync(`psql "${DB_URL}" -c "${sql}"`, { encoding: 'utf8' });
+    console.log(result);
+    return true;
+  } catch (error) {
+    console.error(`❌ Error: ${error.message}`);
+    return false;
+  }
+}
+
+// Helper to run multi-line SQL
+function runMultiLineSQL(sqlLines, description) {
+  console.log(`\n🔍 ${description}...`);
+  try {
+    const sql = sqlLines.join('\n');
+    const result = execSync(`psql "${DB_URL}" -c "${sql}"`, { encoding: 'utf8' });
+    console.log(result);
+    return true;
+  } catch (error) {
+    console.error(`❌ Error: ${error.message}`);
+    return false;
+  }
+}
+
+// Helper to count records matching pattern
+function countRecords(table, column, pattern) {
+  const sql = `SELECT COUNT(*) FROM ${table} WHERE ${column} LIKE '${pattern}';`;
+  try {
+    const result = execSync(`psql "${DB_URL}" -c "${sql}" -t`, { encoding: 'utf8' }).trim();
+    return parseInt(result);
+  } catch (error) {
+    return 0;
+  }
+}
+
+async function main() {
+  console.log('🧹 Cleaning up test records from production database');
+  console.log('=============================================\n');
+
+  // Confirm with user
+  const readline = require('readline');
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  rl.question('⚠️  This will DELETE test records from PRODUCTION database. Continue? (y/N) ', async (answer) => {
+    if (answer.toLowerCase() !== 'y' && answer.toLowerCase() !== 'yes') {
+      console.log('❌ Cleanup cancelled');
+      rl.close();
+      process.exit(0);
+    }
+
+    rl.close();
+
+    console.log('\n📋 Checking test records...\n');
+
+    // Count test players
+    const testPlayerCount = countRecords('players', 'name', '%Test%') +
+                           countRecords('players', 'name', '%Setup%') +
+                           countRecords('players', 'name', '%Home Test%') +
+                           countRecords('players', 'name', '%Home Match Player%') +
+                           countRecords('players', 'name', '%Admin User%');
+    console.log(`Test players found: ${testPlayerCount}`);
+
+    // Count test tournaments
+    const testEventCount = countRecords('events', 'name', '%Test%') +
+                          countRecords('events', 'name', '%Setup%') +
+                          countRecords('events', 'name', '%Recent%');
+    console.log(`Test tournaments found: ${testEventCount}`);
+
+    // Count test users
+    const testUserCount = countRecords('users', 'email', '%test%') +
+                         countRecords('users', 'email', '%setup%');
+    console.log(`Test users found: ${testUserCount}`);
+
+    console.log('\n🔄 Starting cleanup...\n');
+
+    // Step 1: Delete test tournaments (with matches due to cascade delete)
+    console.log('1. Deleting test tournaments (matches will be deleted via cascade)...');
+    runSQL(
+      "DELETE FROM events WHERE (name LIKE '%Test%' OR name LIKE '%Setup%' OR name LIKE '%Recent%');",
+      'Deleted test tournaments'
+    );
+
+    // Step 2: Delete test players (all of them, since we deleted their matches)
+    console.log('\n2. Deleting test players...');
+    runSQL(
+      "DELETE FROM players WHERE (name LIKE '%Test%' OR name LIKE '%Setup%' OR name LIKE '%Home Test%' OR name LIKE '%Home Match Player%' OR name LIKE '%Admin User%');",
+      'Deleted test players'
+    );
+
+    // Step 3: Delete test users (they shouldn't have player associations)
+    console.log('\n3. Deleting test users...');
+    runSQL(
+      "DELETE FROM users WHERE (email LIKE '%test%' OR email LIKE '%setup%') AND \"playerId\" IS NULL;",
+      'Deleted test users'
+    );
+
+    // Summary
+    console.log('\n✅ Cleanup complete!');
+    console.log('\n📊 Remaining test records:');
+    runSQL("SELECT COUNT(*) FROM players WHERE name LIKE '%Test%' OR name LIKE '%Setup%' OR name LIKE '%Home Test%';", 'Remaining test players');
+    runSQL("SELECT COUNT(*) FROM events WHERE name LIKE '%Test%' OR name LIKE '%Setup%';", 'Remaining test tournaments');
+    runSQL("SELECT COUNT(*) FROM users WHERE email LIKE '%test%' OR email LIKE '%setup%';", 'Remaining test users');
+
+    console.log('\n💡 Note: All test records deleted. Matches are automatically deleted');
+    console.log('   via cascade delete when their parent tournament is deleted.');
+  });
+}
+
+// Run main function
+main();
@@ -43,8 +43,17 @@ async function main() {
    });
    
    if (existing) {
-      console.log('User exists, deleting...');
-      await prisma.user.delete({ where: { id: existing.id } });
+      console.log('User exists, updating role to site_admin...');
+      await prisma.user.update({
+        where: { id: existing.id },
+        data: { role: 'site_admin' }
+      });
+    console.log('✅ User role updated to site_admin (superuser)');
+    console.log('\nSuperuser created successfully!');
+    console.log('Email: david@dhg.lol');
+    console.log('Password: adminadmin');
+    console.log('Role: site_admin');
+      return;
    }
    
    // Create user using Better Auth's internal method
@@ -62,13 +71,13 @@ async function main() {
    console.log('   Name:', signUpResult.user.name);
    console.log('   Password: adminadmin');
    
-    // Update the user to have club_admin role
+    // Update the user to have site_admin role (superuser)
    await prisma.user.update({
      where: { id: signUpResult.user.id },
-      data: { role: 'club_admin' }
+      data: { role: 'site_admin' }
    });
    
-    console.log('✅ User role updated to club_admin');
+    console.log('✅ User role updated to site_admin (superuser)');
    
  } catch (error) {
    console.error('❌ Error:', error.message);
@@ -12,7 +12,7 @@ const path = require('path');
 const { execSync } = require('child_process');

 // Configuration
-const REGISTRY = 'dhg.lol:5000';
+const REGISTRY = 'euchre-camp';
 const IMAGE_NAME = 'euchre-camp';

 // Get current version from package.json
@@ -64,8 +64,8 @@ services:
    environment:
      # Database Configuration (REQUIRED: Set via CasaOS environment variables)
      - DATABASE_PROVIDER=postgresql
-      - DATABASE_URL="postgresql://euchre_camp:LINGO5row_hiding@dhg.lol:5432/euchre_camp"
-      - DATABASE_SHADOW_URL="postgresql://euchre_camp:LINGO5row_hiding@dhg.lol:5432/euchre_camp_shadow"
+      - DATABASE_URL=\${DATABASE_URL:-postgresql://euchre_camp:password@db:5432/euchre_camp}
+      - DATABASE_SHADOW_URL=\${DATABASE_SHADOW_URL:-postgresql://euchre_camp:password@db:5432/euchre_camp_shadow}

      # Better Auth Configuration
      - BETTER_AUTH_SECRET=\${BETTER_AUTH_SECRET:-change-this-secret-in-production}
@@ -113,8 +113,8 @@ services:
    environment:
      # Database Configuration
      - DATABASE_PROVIDER=postgresql
-      - DATABASE_URL=postgresql://euchre_camp:password@db:5432/euchre_camp
-      - DATABASE_SHADOW_URL=postgresql://euchre_camp:password@db:5432/euchre_camp_shadow
+      - DATABASE_URL=\${DATABASE_URL:-postgresql://euchre_camp:password@db:5432/euchre_camp}
+      - DATABASE_SHADOW_URL=\${DATABASE_SHADOW_URL:-postgresql://euchre_camp:password@db:5432/euchre_camp_shadow}

      # Better Auth Configuration
      - BETTER_AUTH_SECRET=\${BETTER_AUTH_SECRET:-change-this-secret-in-production}
@@ -181,8 +181,8 @@ services:
    environment:
      # Database Configuration
      - DATABASE_PROVIDER=postgresql
-      - DATABASE_URL=postgresql://euchre_camp:password@db:5432/euchre_camp
-      - DATABASE_SHADOW_URL=postgresql://euchre_camp:password@db:5432/euchre_camp_shadow
+      - DATABASE_URL=\${DATABASE_URL:-postgresql://euchre_camp:password@db:5432/euchre_camp}
+      - DATABASE_SHADOW_URL=\${DATABASE_SHADOW_URL:-postgresql://euchre_camp:password@db:5432/euchre_camp_shadow}

      # Better Auth Configuration
      - BETTER_AUTH_SECRET=\${BETTER_AUTH_SECRET:-dev-secret-change-in-production}
@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+
+/**
+ * Reset Development Database
+ * 
+ * Drops and recreates the development database with a clean state.
+ * Useful for development and testing.
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+// Load environment variables - prioritize explicit DEV_DATABASE_URL
+// Falls back to DATABASE_URL, then .env.development
+const envPath = path.resolve(__dirname, '..', '.env.development');
+if (fs.existsSync(envPath)) {
+  require('dotenv').config({ path: envPath });
+}
+
+// Use DEV_DATABASE_URL if set, otherwise use DATABASE_URL
+const databaseUrl = process.env.DEV_DATABASE_URL || process.env.DATABASE_URL;
+
+// Check if database URL is set
+if (!databaseUrl) {
+  console.error('❌ No database URL set');
+  console.error('Please set DEV_DATABASE_URL or DATABASE_URL environment variable');
+  console.error('Or ensure .env.development file exists with DATABASE_URL');
+  process.exit(1);
+}
+
+// Validate that we're using the dev database
+if (!databaseUrl.includes('_dev') && !databaseUrl.includes('_dev_')) {
+  console.error('❌ ERROR: This script should only be used with the development database!');
+  console.error('   Current URL:', databaseUrl);
+  console.error('   Expected pattern: euchre_camp_dev');
+  console.error('   Please set DEV_DATABASE_URL for development database operations.');
+  process.exit(1);
+}
+
+// Extract database name from URL
+const dbUrl = databaseUrl;
+const dbName = dbUrl.split('/').pop();
+
+console.log('🔄 Resetting development database...\n');
+console.log(`Database: ${dbName}`);
+console.log(`URL: ${dbUrl}\n`);
+
+try {
+  // Drop existing connections
+  console.log('Dropping existing connections...');
+  execSync(
+    `psql "${dbUrl}" -c "SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE datname = '${dbName}' AND pid <> pg_backend_pid();" 2>/dev/null || true`,
+    { stdio: 'pipe' }
+  );
+
+  // Drop the database
+  console.log('Dropping database...');
+  execSync(
+    `psql "${dbUrl}" -c "DROP DATABASE IF EXISTS ${dbName};" 2>/dev/null || true`,
+    { stdio: 'pipe' }
+  );
+
+  // Recreate the database
+  console.log('Creating database...');
+  execSync(`psql "${dbUrl}" -c "CREATE DATABASE ${dbName};"`, { stdio: 'pipe' });
+
+  // Run migrations
+  console.log('Running migrations...');
+  execSync('npx prisma migrate deploy', { stdio: 'inherit' });
+
+  console.log('\n✅ Development database reset successfully!');
+  console.log('\nNext steps:');
+  console.log('1. Seed the database (optional): npm run db:seed');
+  console.log('2. Start development server: npm run dev');
+} catch (error) {
+  console.error('\n❌ Failed to reset database:', error.message);
+  process.exit(1);
+}
@@ -0,0 +1,15 @@
+#!/bin/bash
+# Run tests in a Node.js container (for consistent environment)
+
+set -e
+
+echo "Running tests in node:20-alpine container..."
+echo "This avoids Node.js setup time and ensures consistent environment."
+echo ""
+
+# Run unit tests in container
+docker run --rm \
+  -v "$(pwd):/app" \
+  -w /app \
+  node:20-alpine \
+  sh -c "apk add --no-cache bash git && npm ci && npm run test:run"
@@ -9,8 +9,12 @@ const { execSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');

-// Load .env file if it exists
+// Load .env.development file first (if it exists), then .env file
+const envDevPath = path.resolve(__dirname, '..', '.env.development');
 const envPath = path.resolve(__dirname, '..', '.env');
+if (fs.existsSync(envDevPath)) {
+  require('dotenv').config({ path: envDevPath });
+}
 if (fs.existsSync(envPath)) {
  require('dotenv').config({ path: envPath });
 }
@@ -51,6 +55,22 @@ function createDatabase() {
  }
 }

+function dropDatabase() {
+  try {
+    const dbUrl = process.env.DATABASE_URL;
+    const dbName = dbUrl.split('/').pop();
+
+    // Drop existing connections and database
+    execSync(`psql "${dbUrl}" -c "SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE datname = '${dbName}' AND pid <> pg_backend_pid();" 2>/dev/null || true`, { stdio: 'pipe' });
+    execSync(`psql "${dbUrl}" -c "DROP DATABASE IF EXISTS ${dbName};" 2>/dev/null || true`, { stdio: 'pipe' });
+    console.log(`✅ Database "${dbName}" dropped`);
+    return true;
+  } catch (error) {
+    console.error('❌ Failed to drop database:', error.message);
+    return false;
+  }
+}
+
 function runMigrations() {
  try {
    console.log('🔄 Running migrations...');
@@ -76,6 +96,9 @@ function generatePrismaClient() {
 }

 function main() {
+  const args = process.argv.slice(2);
+  const shouldDrop = args.includes('--drop');
+
  console.log('=== PostgreSQL Setup for EuchreCamp ===\n');

  // Check if DATABASE_URL is set
@@ -90,6 +113,14 @@ function main() {
    process.exit(1);
  }

+  // Drop database if requested
+  if (shouldDrop) {
+    console.log('Dropping existing database...');
+    if (!dropDatabase()) {
+      process.exit(1);
+    }
+  }
+
  // Create database
  if (!createDatabase()) {
    process.exit(1);
@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+
+/**
+ * Switch to development database
+ * Creates a .env.development.local file with development database settings
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const envDevPath = path.join(__dirname, '..', '.env.development');
+const envDevLocalPath = path.join(__dirname, '..', '.env.development.local');
+
+console.log('🔧 Setting up development database...\n');
+
+// Check if .env.development exists
+if (!fs.existsSync(envDevPath)) {
+  console.error('❌ .env.development file not found');
+  console.error('Please create it first or run: npm run db:setup-dev');
+  process.exit(1);
+}
+
+// Copy .env.development to .env.development.local if it doesn't exist
+if (!fs.existsSync(envDevLocalPath)) {
+  fs.copyFileSync(envDevPath, envDevLocalPath);
+  console.log('✅ Created .env.development.local');
+} else {
+  console.log('ℹ️  .env.development.local already exists');
+}
+
+// Set NODE_ENV for the current session
+process.env.NODE_ENV = 'development';
+process.env.DATABASE_PROVIDER = 'postgresql';
+
+// Read the development database URL
+const envContent = fs.readFileSync(envDevPath, 'utf8');
+const match = envContent.match(/DATABASE_URL="([^"]+)"/);
+if (match) {
+  process.env.DATABASE_URL = match[1];
+  console.log(`✅ Development database URL: ${process.env.DATABASE_URL}`);
+}
+
+console.log('\n✅ Development database configured!');
+console.log('\nNext steps:');
+console.log('1. Setup the dev database: npm run db:setup-dev');
+console.log('2. Start development server: npm run dev');
+console.log('\nNote: This script sets environment variables for the current session.');
+console.log('For persistent configuration, use .env.development.local');
@@ -1,24 +1,24 @@
-import { describe, it, expect, vi, beforeEach, MockedFunction } from 'vitest'
+import { describe, it, expect, mock, beforeEach, MockedFunction } from 'bun:test'
 import { render, screen, waitFor } from '@testing-library/react'
 import userEvent from '@testing-library/user-event'
 import EditTournamentForm from '@/components/EditTournamentForm'

 // Mock next/navigation
-vi.mock('next/navigation', () => ({
+mock.module('next/navigation', () => ({
  useRouter: () => ({
-    push: vi.fn(),
+    push: mock(() => {}),
  }),
 }))

 // Mock next/link
-vi.mock('next/link', () => ({
+mock.module('next/link', () => ({
  default: ({ children, href }: { children: React.ReactNode; href: string }) => (
    <a href={href}>{children}</a>
  ),
 }))

 // Mock fetch
-const mockFetch = vi.fn()
+const mockFetch = mock(() => {})
 global.fetch = mockFetch as MockedFunction<typeof global.fetch>

 const mockTournament = {
@@ -40,7 +40,7 @@ const mockTournament = {

 describe('EditTournamentForm', () => {
  beforeEach(() => {
-    vi.clearAllMocks()
+    mock.clearAllMocks()
  })

  it('renders form with initial values', () => {
@@ -5,31 +5,31 @@
 * Tests the navigation component for proper display based on session state
 */

-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { describe, it, expect, mock, beforeEach, afterEach } from 'bun:test'
 import { render, screen, waitFor } from '@testing-library/react'
 import Navigation from '@/components/Navigation'

 // Mock the SessionProvider
-vi.mock('@/components/SessionProvider', () => ({
-  useSession: vi.fn(),
+mock.module('@/components/SessionProvider', () => ({
+  useSession: mock(() => {}),
 }))

 // Mock the auth-client
-vi.mock('@/lib/auth-client', () => ({
+mock.module('@/lib/auth-client', () => ({
  authClient: {
-    signOut: vi.fn(),
+    signOut: mock(() => {}),
  },
 }))

 // Mock fetch for role API call
-global.fetch = vi.fn()
+global.fetch = mock(() => {})

 import { useSession } from '@/components/SessionProvider'

 describe('Epic 1: Navigation Component', () => {
  beforeEach(() => {
-    vi.clearAllMocks()
-    vi.mocked(global.fetch).mockImplementation(async (url) => {
+    mock.clearAllMocks();
+    (global.fetch).mockImplementation(async (url) => {
      if (url?.toString().includes('/api/users/')) {
        return new Response(JSON.stringify({ role: 'player' }), {
          status: 200,
@@ -41,14 +41,14 @@ describe('Epic 1: Navigation Component', () => {
  })

  afterEach(() => {
-    vi.restoreAllMocks()
+    mock.clearAllMocks();
  })

  it('renders the logo and basic links when not logged in', () => {
-    vi.mocked(useSession).mockReturnValue({
+    (useSession).mockReturnValue({
      session: null,
      loading: false,
-      refreshSession: vi.fn(),
+      refreshSession: mock(() => {}),
    })

    render(<Navigation />)
@@ -60,7 +60,7 @@ describe('Epic 1: Navigation Component', () => {
  })

  it('shows user menu when logged in', async () => {
-    vi.mocked(useSession).mockReturnValue({
+    (useSession).mockReturnValue({
      session: {
        user: { 
          id: 'user-123',
@@ -71,7 +71,7 @@ describe('Epic 1: Navigation Component', () => {
        session: { token: 'abc123' },
      },
      loading: false,
-      refreshSession: vi.fn(),
+      refreshSession: mock(() => {}),
    })

    render(<Navigation />)
@@ -85,7 +85,7 @@ describe('Epic 1: Navigation Component', () => {
  })

  it('shows Tournaments link when logged in', async () => {
-    vi.mocked(useSession).mockReturnValue({
+    (useSession).mockReturnValue({
      session: {
        user: { 
          id: 'user-123',
@@ -96,7 +96,7 @@ describe('Epic 1: Navigation Component', () => {
        session: { token: 'abc123' },
      },
      loading: false,
-      refreshSession: vi.fn(),
+      refreshSession: mock(() => {}),
    })

    render(<Navigation />)
@@ -107,7 +107,7 @@ describe('Epic 1: Navigation Component', () => {
  })

  it('shows admin link for club_admin role', async () => {
-    vi.mocked(useSession).mockReturnValue({
+    (useSession).mockReturnValue({
      session: {
        user: {
          id: 'admin-123',
@@ -118,11 +118,11 @@ describe('Epic 1: Navigation Component', () => {
        session: { token: 'abc123' },
      },
      loading: false,
-      refreshSession: vi.fn(),
-    })
+      refreshSession: mock(() => {}),
+    });

    // Mock fetch to return club_admin role
-    vi.mocked(global.fetch).mockImplementation(async (url) => {
+    (global.fetch).mockImplementation(async (url) => {
      if (url?.toString().includes('/api/users/admin-123/role')) {
        return new Response(JSON.stringify({ role: 'club_admin' }), {
          status: 200,
@@ -141,7 +141,7 @@ describe('Epic 1: Navigation Component', () => {
  })

  it('hides admin link for non-admin users', async () => {
-    vi.mocked(useSession).mockReturnValue({
+    (useSession).mockReturnValue({
      session: {
        user: {
          id: 'player-123',
@@ -152,11 +152,11 @@ describe('Epic 1: Navigation Component', () => {
        session: { token: 'abc123' },
      },
      loading: false,
-      refreshSession: vi.fn(),
-    })
+      refreshSession: mock(() => {}),
+    });

    // Mock fetch to return player role (already set in beforeEach, but explicit here)
-    vi.mocked(global.fetch).mockImplementation(async (url) => {
+    (global.fetch).mockImplementation(async (url) => {
      if (url?.toString().includes('/api/users/')) {
        return {
          json: () => Promise.resolve({ role: 'player' }),
@@ -176,10 +176,10 @@ describe('Epic 1: Navigation Component', () => {
  })

  it('shows loading state', () => {
-    vi.mocked(useSession).mockReturnValue({
+    (useSession).mockReturnValue({
      session: null,
      loading: true,
-      refreshSession: vi.fn(),
+      refreshSession: mock(() => {}),
    })

    render(<Navigation />)
@@ -1,23 +1,23 @@
-import { describe, it, expect, vi, beforeEach, MockedFunction } from 'vitest'
+import { describe, it, expect, mock, beforeEach, MockedFunction } from 'bun:test'
 import { getSession } from '@/lib/auth-simple'

 // Mock next/headers
 vi.mock('next/headers', () => ({
-  cookies: vi.fn().mockResolvedValue({
-    get: vi.fn().mockReturnValue({ name: 'better-auth.session_token', value: 'test-token' }),
+  cookies: mock(() => {}).mockResolvedValue({
+    get: mock(() => {}).mockReturnValue({ name: 'better-auth.session_token', value: 'test-token' }),
  }),
-  headers: vi.fn().mockResolvedValue({
-    get: vi.fn().mockReturnValue(null),
+  headers: mock(() => {}).mockResolvedValue({
+    get: mock(() => {}).mockReturnValue(null),
  }),
 }))

 // Mock fetch
-const mockFetch = vi.fn()
+const mockFetch = mock(() => {})
 global.fetch = mockFetch as MockedFunction<typeof global.fetch>

 describe('getSession', () => {
  beforeEach(() => {
-    vi.clearAllMocks()
+    mock.clearAllMocks()
  })

  it('returns session data when auth API returns 200', async () => {
@@ -26,7 +26,7 @@ describe('getSession', () => {
      user: { id: 'user-123', email: 'test@example.com' },
    }

-    mockFetch.mockResolvedValue(
+    mockFetch.mockImplementation(async () => 
      new Response(JSON.stringify(mockSession), { status: 200 })
    )

@@ -37,7 +37,7 @@ describe('getSession', () => {
  })

  it('returns null when auth API returns non-200 status', async () => {
-    mockFetch.mockResolvedValue(
+    mockFetch.mockImplementation(async () => 
      new Response(null, { status: 401 })
    )

@@ -0,0 +1,12 @@
+// Setup file for Bun test runner to provide DOM environment
+import { JSDOM } from 'jsdom';
+import '@testing-library/jest-dom';
+
+const dom = new JSDOM('<!DOCTYPE html><html><body></body></html>', {
+  url: 'http://localhost',
+  pretendToBeVisual: true,
+});
+
+(global as any).window = dom.window;
+(global as any).document = dom.window.document;
+(global as any).navigator = dom.window.navigator;
@@ -5,10 +5,64 @@

 import { chromium, type FullConfig } from '@playwright/test';
 import { prisma } from '@/lib/prisma';
+import { cleanupAllTestData } from '@/__tests__/test-utils';
+import path from 'path';
+import fs from 'fs';
+
+// Load .env file first, then .env.development (which will override .env)
+const envPath = path.resolve(process.cwd(), '.env');
+const envDevPath = path.resolve(process.cwd(), '.env.development');
+
+// Load base .env file
+if (fs.existsSync(envPath)) {
+  require('dotenv').config({ path: envPath });
+}
+
+// Load .env.development file (will override .env settings)
+if (fs.existsSync(envDevPath)) {
+  require('dotenv').config({ path: envDevPath, override: true });
+}

 const authFile = 'playwright/.auth/user.json';
 const adminAuthFile = 'playwright/.auth/admin.json';

+// Check if we're using the dev database
+function isDevDatabase(): boolean {
+  const dbUrl = process.env.DATABASE_URL || '';
+  return dbUrl.includes('euchre_camp_dev');
+}
+
+function isProductionDatabase(): boolean {
+  const dbUrl = process.env.DATABASE_URL || '';
+  return dbUrl.includes('euchre_camp') && !dbUrl.includes('_dev');
+}
+
+// Strict check - fail if using production database
+if (isProductionDatabase()) {
+  console.error('');
+  console.error('='.repeat(80));
+  console.error('CRITICAL ERROR: Tests are attempting to run against PRODUCTION database!');
+  console.error('='.repeat(80));
+  console.error('');
+  console.error('Current DATABASE_URL:', process.env.DATABASE_URL);
+  console.error('');
+  console.error('Tests MUST run against the development database (euchre_camp_dev)');
+  console.error('');
+    console.error('To fix this:');
+    console.error('  1. Run: npm run test:acceptance');
+    console.error('  2. Or set: DATABASE_URL environment variable to dev database URL');
+    console.error('  3. Or load .env.development: source .env.development && npm run test:acceptance');
+  console.error('');
+  console.error('Aborting test execution to prevent data corruption.');
+  console.error('');
+  process.exit(1);
+}
+
+if (!isDevDatabase()) {
+  console.warn('⚠️  WARNING: DATABASE_URL does not contain euchre_camp_dev');
+  console.warn('   Current DATABASE_URL:', process.env.DATABASE_URL);
+}
+
 export default async function globalSetup(config: FullConfig) {
  const baseURL = config.projects[0]?.use?.baseURL || 'http://localhost:3000';
  
@@ -144,18 +198,13 @@ export default async function globalSetup(config: FullConfig) {

  // Return teardown function
  return async () => {
-    // Clean up test users
+    console.log('\n=== Global Teardown ===');
+    
+    // Clean up all test data
    try {
-      await prisma.user.deleteMany({
-        where: {
-          email: {
-            startsWith: 'setup-'
-          }
-        }
-      });
-      console.log('Cleaned up test users');
+      await cleanupAllTestData();
    } catch (error) {
-      console.error('Error cleaning up test users:', error);
+      console.error('Error cleaning up test data:', error);
    } finally {
      await prisma.$disconnect();
    }
@@ -1,22 +1,27 @@
 import { test, expect } from '@playwright/test'
 import { prisma } from '@/lib/prisma'
+import { createTestPlayer, cleanupTestRecords, getCreatedRecordCounts } from '@/__tests__/test-utils'

 test.describe('Home Page', () => {
+  test.beforeEach(async () => {
+    // Clean up any existing test records before each test
+    await cleanupTestRecords();
+  });
+
+  test.afterEach(async () => {
+    // Clean up test records after each test
+    await cleanupTestRecords();
+  });
+
  test('should display top 10 players', async ({ page }) => {
    // Create some test players with unique names and very high Elo to ensure they're in top 10
    const timestamp = Date.now()
    const players = []
    for (let i = 0; i < 3; i++) {
      const playerName = `Home Test Player ${timestamp} ${i + 1}`
-      const player = await prisma.player.create({
-        data: {
-          name: playerName,
-          normalizedName: playerName.toLowerCase(),
-          currentElo: 2000 - i * 10, // Very high Elo to ensure they're in top 10
-          gamesPlayed: 10 + i,
-          wins: 5 + Math.floor(i / 2),
-          losses: 5 + Math.ceil(i / 2),
-        },
+      const player = await createTestPlayer({
+        name: playerName,
+        currentElo: 2000 - i * 10,
      })
      players.push(player)
    }
@@ -33,10 +38,9 @@ test.describe('Home Page', () => {
      page.locator(`a:has-text("Home Test Player ${timestamp} 1")`)
    ).toBeVisible()

-    // Clean up
-    for (const player of players) {
-      await prisma.player.delete({ where: { id: player.id } })
-    }
+    // Verify cleanup will work
+    const counts = getCreatedRecordCounts();
+    expect(counts.players).toBe(3);
  })

  test('should display club president', async ({ page }) => {
@@ -0,0 +1,117 @@
+/**
+ * E2E Test: Tournament Edit with allowTies
+ * 
+ * User Story: As a tournament admin, I want to edit tournament settings including allowTies
+ * 
+ * Acceptance Criteria:
+ * - Can edit tournament settings
+ * - allowTies checkbox can be toggled
+ * - allowTies value is saved correctly
+ */
+
+import { test, expect } from '@playwright/test';
+import { prisma } from '@/lib/prisma';
+
+test.describe('Tournament Edit - allowTies functionality', () => {
+  let tournamentId: number;
+
+  test.beforeAll(async () => {
+    // Create a test tournament for editing
+    const tournament = await prisma.event.create({
+      data: {
+        name: 'Test Tournament for AllowTies Edit',
+        eventType: 'tournament',
+        format: 'round_robin',
+        status: 'planned',
+        allowTies: false,
+        targetScore: 5,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      },
+    });
+    tournamentId = tournament.id;
+  });
+
+  test.afterAll(async () => {
+    // Clean up test tournament
+    if (tournamentId) {
+      await prisma.event.delete({
+        where: { id: tournamentId },
+      });
+    }
+  });
+
+  test('should display allowTies checkbox on edit form', async ({ page }) => {
+    // Navigate to tournament edit page
+    await page.goto(`/admin/tournaments/${tournamentId}/edit`);
+
+    // Wait for form to load
+    await expect(page.locator('text=Tournament Name')).toBeVisible();
+
+    // Check that allowTies checkbox exists
+    const allowTiesCheckbox = page.locator('input[name="allowTies"]');
+    await expect(allowTiesCheckbox).toBeVisible();
+    await expect(allowTiesCheckbox).not.toBeChecked();
+  });
+
+  test('should save allowTies when toggled to true', async ({ page }) => {
+    // Navigate to tournament edit page
+    await page.goto(`/admin/tournaments/${tournamentId}/edit`);
+
+    // Wait for form to load
+    await expect(page.locator('text=Tournament Name')).toBeVisible();
+
+    // Toggle allowTies checkbox
+    const allowTiesCheckbox = page.locator('input[name="allowTies"]');
+    await allowTiesCheckbox.check();
+    await expect(allowTiesCheckbox).toBeChecked();
+
+    // Submit form
+    await page.click('button[type="submit"]');
+
+    // Wait for success message
+    await expect(page.locator('text=Tournament updated successfully')).toBeVisible({ timeout: 5000 });
+
+    // Verify allowTies was saved by checking the database
+    const updatedTournament = await prisma.event.findUnique({
+      where: { id: tournamentId },
+    });
+
+    expect(updatedTournament?.allowTies).toBe(true);
+  });
+
+  test('should save allowTies when toggled to false', async ({ page }) => {
+    // First, set allowTies to true
+    await prisma.event.update({
+      where: { id: tournamentId },
+      data: { allowTies: true },
+    });
+
+    // Navigate to tournament edit page
+    await page.goto(`/admin/tournaments/${tournamentId}/edit`);
+
+    // Wait for form to load
+    await expect(page.locator('text=Tournament Name')).toBeVisible();
+
+    // Verify checkbox is checked
+    const allowTiesCheckbox = page.locator('input[name="allowTies"]');
+    await expect(allowTiesCheckbox).toBeChecked();
+
+    // Uncheck allowTies checkbox
+    await allowTiesCheckbox.uncheck();
+    await expect(allowTiesCheckbox).not.toBeChecked();
+
+    // Submit form
+    await page.click('button[type="submit"]');
+
+    // Wait for success message
+    await expect(page.locator('text=Tournament updated successfully')).toBeVisible({ timeout: 5000 });
+
+    // Verify allowTies was saved by checking the database
+    const updatedTournament = await prisma.event.findUnique({
+      where: { id: tournamentId },
+    });
+
+    expect(updatedTournament?.allowTies).toBe(false);
+  });
+});
@@ -0,0 +1,274 @@
+/**
+ * Test Utilities for EuchreCamp
+ * 
+ * Provides helper functions for creating and cleaning up test data
+ */
+
+import { prisma } from '@/lib/prisma';
+import type { User, Player, Event, Match } from '@prisma/client';
+
+// Track created test records for cleanup
+const createdRecords = {
+  users: [] as string[],
+  players: [] as number[],
+  events: [] as number[],
+  matches: [] as number[],
+};
+
+/**
+ * Create a test user with optional player association
+ */
+export async function createTestUser(options: {
+  email?: string;
+  name?: string;
+  role?: string;
+  playerId?: number | null;
+} = {}) {
+  const timestamp = Date.now();
+  const email = options.email || `test-user-${timestamp}@example.com`;
+  const name = options.name || `Test User ${timestamp}`;
+  const role = options.role || 'player';
+
+  const user = await prisma.user.create({
+    data: {
+      email,
+      name,
+      role,
+      playerId: options.playerId,
+    },
+  });
+
+  createdRecords.users.push(user.id);
+  return user;
+}
+
+/**
+ * Create a test player
+ */
+export async function createTestPlayer(options: {
+  name?: string;
+  currentElo?: number;
+} = {}) {
+  const timestamp = Date.now();
+  const name = options.name || `Test Player ${timestamp}`;
+
+  const player = await prisma.player.create({
+    data: {
+      name,
+      normalizedName: name.toLowerCase(),
+      currentElo: options.currentElo || 1000,
+    },
+  });
+
+  createdRecords.players.push(player.id);
+  return player;
+}
+
+/**
+ * Create a test event (tournament)
+ */
+export async function createTestEvent(options: {
+  name?: string;
+  ownerId?: string;
+} = {}) {
+  const timestamp = Date.now();
+  const name = options.name || `Test Event ${timestamp}`;
+
+  const event = await prisma.event.create({
+    data: {
+      name,
+      eventType: 'tournament',
+      format: 'round_robin',
+      status: 'planned',
+      ownerId: options.ownerId,
+    },
+  });
+
+  createdRecords.events.push(event.id);
+  return event;
+}
+
+/**
+ * Create a test match
+ */
+export async function createTestMatch(options: {
+  eventId?: number;
+  team1P1Id: number;
+  team1P2Id: number;
+  team2P1Id: number;
+  team2P2Id: number;
+  team1Score?: number;
+  team2Score?: number;
+}) {
+  const timestamp = Date.now();
+
+  const match = await prisma.match.create({
+    data: {
+      eventId: options.eventId,
+      team1P1Id: options.team1P1Id,
+      team1P2Id: options.team1P2Id,
+      team2P1Id: options.team2P1Id,
+      team2P2Id: options.team2P2Id,
+      team1Score: options.team1Score ?? 10,
+      team2Score: options.team2Score ?? 5,
+      status: 'completed',
+    },
+  });
+
+  createdRecords.matches.push(match.id);
+  return match;
+}
+
+/**
+ * Clean up all created test records
+ */
+export async function cleanupTestRecords() {
+  console.log('🧹 Cleaning up test records...');
+
+  try {
+    // Delete matches first (they reference players)
+    if (createdRecords.matches.length > 0) {
+      await prisma.match.deleteMany({
+        where: { id: { in: createdRecords.matches } },
+      });
+      console.log(`  Deleted ${createdRecords.matches.length} matches`);
+    }
+
+    // Delete events
+    if (createdRecords.events.length > 0) {
+      await prisma.event.deleteMany({
+        where: { id: { in: createdRecords.events } },
+      });
+      console.log(`  Deleted ${createdRecords.events.length} events`);
+    }
+
+    // Delete users first (to break player associations)
+    if (createdRecords.users.length > 0) {
+      await prisma.user.deleteMany({
+        where: { id: { in: createdRecords.users } },
+      });
+      console.log(`  Deleted ${createdRecords.users.length} users`);
+    }
+
+    // Delete players
+    if (createdRecords.players.length > 0) {
+      await prisma.player.deleteMany({
+        where: { id: { in: createdRecords.players } },
+      });
+      console.log(`  Deleted ${createdRecords.players.length} players`);
+    }
+
+    // Reset tracking
+    createdRecords.users = [];
+    createdRecords.players = [];
+    createdRecords.events = [];
+    createdRecords.matches = [];
+
+    console.log('✅ Test records cleaned up successfully');
+  } catch (error) {
+    console.error('❌ Error cleaning up test records:', error);
+    // Still reset tracking to avoid trying to delete again
+    createdRecords.users = [];
+    createdRecords.players = [];
+    createdRecords.events = [];
+    createdRecords.matches = [];
+  }
+}
+
+/**
+ * Get count of created records (for assertions)
+ */
+export function getCreatedRecordCounts() {
+  return {
+    users: createdRecords.users.length,
+    players: createdRecords.players.length,
+    events: createdRecords.events.length,
+    matches: createdRecords.matches.length,
+  };
+}
+
+/**
+ * Clean up test users by email pattern
+ */
+export async function cleanupTestUsersByEmailPattern(pattern: string = 'test-') {
+  try {
+    const result = await prisma.user.deleteMany({
+      where: {
+        email: {
+          contains: pattern,
+        },
+      },
+    });
+    console.log(`  Deleted ${result.count} test users matching pattern "${pattern}"`);
+    return result.count;
+  } catch (error) {
+    console.error('❌ Error cleaning up test users:', error);
+    return 0;
+  }
+}
+
+/**
+ * Clean up test players by name pattern
+ */
+export async function cleanupTestPlayersByNamePattern(pattern: string = 'Test ') {
+  try {
+    const result = await prisma.player.deleteMany({
+      where: {
+        name: {
+          contains: pattern,
+        },
+      },
+    });
+    console.log(`  Deleted ${result.count} test players matching pattern "${pattern}"`);
+    return result.count;
+  } catch (error) {
+    console.error('❌ Error cleaning up test players:', error);
+    return 0;
+  }
+}
+
+/**
+ * Clean up all test data (aggressive cleanup)
+ */
+export async function cleanupAllTestData() {
+  console.log('🧹 Aggressive cleanup of all test data...');
+
+  try {
+    // Delete test users first
+    const userResult = await prisma.user.deleteMany({
+      where: {
+        email: {
+          contains: 'test-',
+        },
+      },
+    });
+    console.log(`  Deleted ${userResult.count} test users`);
+
+    // Delete test players
+    const playerResult = await prisma.player.deleteMany({
+      where: {
+        name: {
+          contains: 'Test ',
+        },
+      },
+    });
+    console.log(`  Deleted ${playerResult.count} test players`);
+
+    // Delete test events
+    const eventResult = await prisma.event.deleteMany({
+      where: {
+        name: {
+          contains: 'Test ',
+        },
+      },
+    });
+    console.log(`  Deleted ${eventResult.count} test events`);
+
+    console.log('✅ All test data cleaned up');
+  } catch (error) {
+    console.error('❌ Error during aggressive cleanup:', error);
+  }
+}
+
+// Export cleanup function for global setup/teardown
+export const testCleanup = cleanupTestRecords;
@@ -4,7 +4,7 @@
 * Tests the mathematical correctness of Elo calculations and rating updates
 */

-import { describe, test, expect } from 'vitest';
+import { describe, test, expect } from 'bun:test';
 import { calculateEloChange, calculateExpectedScore, calculateTeamElo } from '@/lib/elo-utils';

 describe('Elo Rating System', () => {
@@ -4,7 +4,7 @@
 * Tests for ID parsing and validation in API routes and pages
 */

-import { describe, test, expect } from 'vitest';
+import { describe, test, expect } from 'bun:test';

 describe('ID Validation', () => {
  describe('parseInt with validation', () => {
@@ -4,7 +4,7 @@
 * Tests the permission system for tournament management
 */

-import { describe, test, expect, vi } from 'vitest';
+import { describe, test, expect, mock } from 'bun:test';
 import { hasRole, canManageTournament, canCreateTournaments } from '@/lib/permissions';
 import { getSession } from '@/lib/auth-simple';
 import { prisma } from '@/lib/prisma';
@@ -24,17 +24,17 @@ const createMockUser = (id: string, email: string, role: string): User => ({
 });

 // Mock the getSession and prisma functions
-vi.mock('@/lib/auth-simple', () => ({
-  getSession: vi.fn(),
+mock.module('@/lib/auth-simple', () => ({
+  getSession: mock(() => {}),
 }));

-vi.mock('@/lib/prisma', () => ({
+mock.module('@/lib/prisma', () => ({
  prisma: {
    user: {
-      findUnique: vi.fn(),
+      findUnique: mock(() => {}),
    },
    event: {
-      findUnique: vi.fn(),
+      findUnique: mock(() => {}),
    },
  },
 }));
@@ -42,11 +42,11 @@ vi.mock('@/lib/prisma', () => ({
 describe('Permissions', () => {
  describe('hasRole', () => {
    test('should allow club_admin to access tournament_admin resources', async () => {
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
        user: { id: '1', email: 'test@example.com' },
        session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(
+      }));
+      prisma.user.findUnique.mockImplementation(async () => 
        createMockUser('1', 'test@example.com', 'club_admin')
      );

@@ -55,11 +55,11 @@ describe('Permissions', () => {
    });

    test('should deny player from accessing tournament_admin resources', async () => {
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
        user: { id: '1', email: 'test@example.com' },
        session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(
+      }));
+      prisma.user.findUnique.mockImplementation(async () => 
        createMockUser('1', 'test@example.com', 'player')
      );

@@ -68,7 +68,7 @@ describe('Permissions', () => {
    });

    test('should deny unauthenticated user', async () => {
-      vi.mocked(getSession).mockResolvedValue(null);
+      getSession.mockImplementation(async () => null);

      const result = await hasRole('club_admin');
      expect(result.allowed).toBe(false);
@@ -78,11 +78,11 @@ describe('Permissions', () => {

  describe('canManageTournament', () => {
    test('should allow club_admin to manage any tournament', async () => {
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
        user: { id: 'admin-1', email: 'admin@example.com' },
        session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(
+      }));
+      prisma.user.findUnique.mockImplementation(async () => 
        createMockUser('admin-1', 'admin@example.com', 'club_admin')
      );

@@ -91,11 +91,11 @@ describe('Permissions', () => {
    });

    test('should deny player from managing tournaments', async () => {
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
        user: { id: 'player-1', email: 'player@example.com' },
        session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(
+      }));
+      prisma.user.findUnique.mockImplementation(async () => 
        createMockUser('player-1', 'player@example.com', 'player')
      );

@@ -107,11 +107,11 @@ describe('Permissions', () => {

  describe('canCreateTournaments', () => {
    test('should allow tournament_admin to create tournaments', async () => {
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
        user: { id: 'admin-1', email: 'admin@example.com' },
        session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(
+      }));
+      prisma.user.findUnique.mockImplementation(async () => 
        createMockUser('admin-1', 'admin@example.com', 'tournament_admin')
      );

@@ -120,11 +120,11 @@ describe('Permissions', () => {
    });

    test('should allow club_admin to create tournaments', async () => {
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
        user: { id: 'admin-1', email: 'admin@example.com' },
        session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(
+      }));
+      prisma.user.findUnique.mockImplementation(async () => 
        createMockUser('admin-1', 'admin@example.com', 'club_admin')
      );

@@ -133,11 +133,11 @@ describe('Permissions', () => {
    });

    test('should deny player from creating tournaments', async () => {
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
        user: { id: 'player-1', email: 'player@example.com' },
        session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(
+      }));
+      prisma.user.findUnique.mockImplementation(async () => 
        createMockUser('player-1', 'player@example.com', 'player')
      );

@@ -4,15 +4,15 @@
 * Tests the player deduplication logic for CSV uploads
 */

-import { describe, test, expect, vi, beforeEach } from 'vitest';
+import { describe, test, expect, mock, beforeEach } from 'bun:test';
 import { prisma } from '@/lib/prisma';

 // Mock the prisma module
-vi.mock('@/lib/prisma', () => ({
+mock.module('@/lib/prisma', () => ({
  prisma: {
    player: {
-      findFirst: vi.fn(),
-      create: vi.fn(),
+      findFirst: mock(() => {}),
+      create: mock(() => {}),
    },
  },
 }));
@@ -46,7 +46,7 @@ async function findOrCreatePlayer(name: string) {

 describe('Player Deduplication', () => {
  beforeEach(() => {
-    vi.clearAllMocks();
+    mock.clearAllMocks();
  });

  describe('findOrCreatePlayer', () => {
@@ -64,7 +64,7 @@ describe('Player Deduplication', () => {
        rating: 0,
      };

-      vi.mocked(prisma.player.findFirst).mockResolvedValue(mockPlayer);
+      prisma.player.findFirst.mockImplementation(async () => mockPlayer);

      const result = await findOrCreatePlayer('Emily');

@@ -89,7 +89,7 @@ describe('Player Deduplication', () => {
        rating: 0,
      };

-      vi.mocked(prisma.player.findFirst).mockResolvedValue(mockPlayer);
+      prisma.player.findFirst.mockImplementation(async () => mockPlayer);

      const result = await findOrCreatePlayer('EMILY');

@@ -114,7 +114,7 @@ describe('Player Deduplication', () => {
        rating: 0,
      };

-      vi.mocked(prisma.player.findFirst).mockResolvedValue(mockPlayer);
+      prisma.player.findFirst.mockImplementation(async () => mockPlayer);

      const result = await findOrCreatePlayer('  Emily  ');

@@ -126,7 +126,7 @@ describe('Player Deduplication', () => {
    });

    test('should create new player if not found', async () => {
-      vi.mocked(prisma.player.findFirst).mockResolvedValue(null);
+      prisma.player.findFirst.mockImplementation(async () => null);

      const newPlayer = {
        id: 100,
@@ -141,7 +141,7 @@ describe('Player Deduplication', () => {
        updatedAt: new Date(),
      };

-      vi.mocked(prisma.player.create).mockResolvedValue(newPlayer);
+      prisma.player.create.mockImplementation(async () => newPlayer);

      const result = await findOrCreatePlayer('NewPlayer');

@@ -162,7 +162,7 @@ describe('Player Deduplication', () => {
    });

    test('should handle names with special characters', async () => {
-      vi.mocked(prisma.player.findFirst).mockResolvedValue(null);
+      prisma.player.findFirst.mockImplementation(async () => null);

      const newPlayer = {
        id: 100,
@@ -177,7 +177,7 @@ describe('Player Deduplication', () => {
        updatedAt: new Date(),
      };

-      vi.mocked(prisma.player.create).mockResolvedValue(newPlayer);
+      prisma.player.create.mockImplementation(async () => newPlayer);

      const result = await findOrCreatePlayer('Test-Player_123');

@@ -195,7 +195,7 @@ describe('Player Deduplication', () => {
    });

    test('should handle names with spaces', async () => {
-      vi.mocked(prisma.player.findFirst).mockResolvedValue(null);
+      prisma.player.findFirst.mockImplementation(async () => null);

      const newPlayer = {
        id: 100,
@@ -210,7 +210,7 @@ describe('Player Deduplication', () => {
        updatedAt: new Date(),
      };

-      vi.mocked(prisma.player.create).mockResolvedValue(newPlayer);
+      prisma.player.create.mockImplementation(async () => newPlayer);

      const result = await findOrCreatePlayer('Dave B');

@@ -242,7 +242,7 @@ describe('Player Deduplication', () => {
        rating: 0,
      };

-      vi.mocked(prisma.player.findFirst).mockResolvedValue(mockPlayer);
+      prisma.player.findFirst.mockImplementation(async () => mockPlayer);

      const result1 = await findOrCreatePlayer('EMILY');
      const result2 = await findOrCreatePlayer('Emily');
@@ -255,7 +255,7 @@ describe('Player Deduplication', () => {
    });

    test('should handle empty or whitespace-only names', async () => {
-      vi.mocked(prisma.player.findFirst).mockResolvedValue(null);
+      prisma.player.findFirst.mockImplementation(async () => null);

      const newPlayer = {
        id: 100,
@@ -270,7 +270,7 @@ describe('Player Deduplication', () => {
        updatedAt: new Date(),
      };

-      vi.mocked(prisma.player.create).mockResolvedValue(newPlayer);
+      prisma.player.create.mockImplementation(async () => newPlayer);

      const result = await findOrCreatePlayer('   ');

@@ -320,7 +320,7 @@ describe('Player Deduplication', () => {
        rating: 0,
      };

-      vi.mocked(prisma.player.findFirst)
+      prisma.player.findFirst
        .mockResolvedValueOnce(existingPlayer) // First call for "Emily"
        .mockResolvedValueOnce(existingPlayer) // Second call for "EMILY"
        .mockResolvedValueOnce(existingPlayer); // Third call for "  Emily  "
@@ -7,24 +7,24 @@
 * - Partnership performance
 */

-import { describe, test, expect, vi, beforeEach } from 'vitest';
+import { describe, test, expect, mock, beforeEach } from 'bun:test';
 import { prisma } from '@/lib/prisma';
 import type { Player, Event, Match, PartnershipStat } from '@prisma/client';

 // Mock the prisma module
-vi.mock('@/lib/prisma', () => ({
+mock.module('@/lib/prisma', () => ({
  prisma: {
    player: {
-      findUnique: vi.fn(),
+      findUnique: mock(() => {}),
    },
    event: {
-      findMany: vi.fn(),
+      findMany: mock(() => {}),
    },
    match: {
-      findMany: vi.fn(),
+      findMany: mock(() => {}),
    },
    partnershipStat: {
-      findMany: vi.fn(),
+      findMany: mock(() => {}),
    },
  },
 }));
@@ -111,7 +111,7 @@ const createMockPartnershipStat = (

 describe('Player Profile Enhancements', () => {
  beforeEach(() => {
-    vi.clearAllMocks();
+    mock.clearAllMocks();
  });

  describe('Tournaments Participated', () => {
@@ -122,8 +122,8 @@ describe('Player Profile Enhancements', () => {
        createMockTournament(2, 'Tournament B'),
      ];

-      vi.mocked(prisma.player.findUnique).mockResolvedValue(mockPlayer);
-      vi.mocked(prisma.event.findMany).mockResolvedValue(mockTournaments);
+      prisma.player.findUnique.mockImplementation(async () => mockPlayer);
+      prisma.event.findMany.mockImplementation(async () => mockTournaments);

      // Simulate the query that would be run
      const tournaments = await prisma.event.findMany({
@@ -145,8 +145,8 @@ describe('Player Profile Enhancements', () => {
    test('should return empty array if player has no tournaments', async () => {
      const mockPlayer = createMockPlayer(1, 'Test Player');

-      vi.mocked(prisma.player.findUnique).mockResolvedValue(mockPlayer);
-      vi.mocked(prisma.event.findMany).mockResolvedValue([]);
+      prisma.player.findUnique.mockImplementation(async () => mockPlayer);
+      prisma.event.findMany.mockImplementation(async () => []);

      const tournaments = await prisma.event.findMany({
        where: {
@@ -173,8 +173,8 @@ describe('Player Profile Enhancements', () => {
        createMockMatch(2, 1, 3, 5, 6, 4, 4),
      ];

-      vi.mocked(prisma.player.findUnique).mockResolvedValue(mockPlayer);
-      vi.mocked(prisma.match.findMany).mockResolvedValue(mockMatches);
+      prisma.player.findUnique.mockImplementation(async () => mockPlayer);
+      prisma.match.findMany.mockImplementation(async () => mockMatches);

      // Simulate the query that would be run
      const matches = await prisma.match.findMany({
@@ -204,8 +204,8 @@ describe('Player Profile Enhancements', () => {
    test('should return empty array if player has no matches', async () => {
      const mockPlayer = createMockPlayer(1, 'Test Player');

-      vi.mocked(prisma.player.findUnique).mockResolvedValue(mockPlayer);
-      vi.mocked(prisma.match.findMany).mockResolvedValue([]);
+      prisma.player.findUnique.mockImplementation(async () => mockPlayer);
+      prisma.match.findMany.mockImplementation(async () => []);

      const matches = await prisma.match.findMany({
        where: {
@@ -240,8 +240,8 @@ describe('Player Profile Enhancements', () => {
        createMockPartnershipStat(2, 1, 3, 5, 2, 3),
      ];

-      vi.mocked(prisma.player.findUnique).mockResolvedValue(mockPlayer);
-      vi.mocked(prisma.partnershipStat.findMany).mockResolvedValue(mockPartnershipStats);
+      prisma.player.findUnique.mockImplementation(async () => mockPlayer);
+      prisma.partnershipStat.findMany.mockImplementation(async () => mockPartnershipStats);

      // Simulate the query that would be run
      const partnershipStats = await prisma.partnershipStat.findMany({
@@ -265,8 +265,8 @@ describe('Player Profile Enhancements', () => {
    test('should return empty array if player has no partnership data', async () => {
      const mockPlayer = createMockPlayer(1, 'Test Player');

-      vi.mocked(prisma.player.findUnique).mockResolvedValue(mockPlayer);
-      vi.mocked(prisma.partnershipStat.findMany).mockResolvedValue([]);
+      prisma.player.findUnique.mockImplementation(async () => mockPlayer);
+      prisma.partnershipStat.findMany.mockImplementation(async () => []);

      const partnershipStats = await prisma.partnershipStat.findMany({
        where: {
@@ -5,33 +5,33 @@
 */

 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { describe, test, expect, beforeEach, vi } from 'vitest';
+import { describe, test, expect, beforeEach, mock } from 'bun:test';
 import { recalculateAllElo } from '@/lib/elo-utils';

 // Mock Prisma client
 const mockPrisma = {
  player: {
-    updateMany: vi.fn().mockResolvedValue({ count: 0 }),
-    update: vi.fn().mockResolvedValue({}),
+    updateMany: mock(() => {}).mockResolvedValue({ count: 0 }),
+    update: mock(() => {}).mockResolvedValue({}),
  },
  eloSnapshot: {
-    deleteMany: vi.fn().mockResolvedValue({ count: 0 }),
-    create: vi.fn().mockResolvedValue({}),
+    deleteMany: mock(() => {}).mockResolvedValue({ count: 0 }),
+    create: mock(() => {}).mockResolvedValue({}),
  },
  partnershipStat: {
-    deleteMany: vi.fn().mockResolvedValue({ count: 0 }),
-    findFirst: vi.fn().mockResolvedValue(null), // No existing stats initially
-    update: vi.fn().mockResolvedValue({}),
-    create: vi.fn().mockResolvedValue({}),
+    deleteMany: mock(() => {}).mockResolvedValue({ count: 0 }),
+    findFirst: mock(() => {}).mockResolvedValue(null), // No existing stats initially
+    update: mock(() => {}).mockResolvedValue({}),
+    create: mock(() => {}).mockResolvedValue({}),
  },
  match: {
-    findMany: vi.fn().mockResolvedValue([]),
+    findMany: mock(() => {}).mockResolvedValue([]),
  },
 };

 describe('recalculateAllElo', () => {
  beforeEach(() => {
-    vi.clearAllMocks();
+    mock.clearAllMocks();
  });

  test('should reset all player stats to zero', async () => {
@@ -5,25 +5,25 @@
 * Regression tests for the issue where tournament_admin users were redirected to login
 */

-import { describe, test, expect, vi, beforeEach } from 'vitest';
+import { describe, test, expect, mock, beforeEach } from 'bun:test';
 import { canManageTournament, ownsTournament, getManageableTournaments } from '@/lib/permissions';
 import { getSession } from '@/lib/auth-simple';
 import { prisma } from '@/lib/prisma';
 import type { User, Event } from '@prisma/client';

 // Mock the getSession and prisma functions
-vi.mock('@/lib/auth-simple', () => ({
-  getSession: vi.fn(),
+mock.module('@/lib/auth-simple', () => ({
+  getSession: mock(() => {}),
 }));

-vi.mock('@/lib/prisma', () => ({
+mock.module('@/lib/prisma', () => ({
  prisma: {
    user: {
-      findUnique: vi.fn(),
+      findUnique: mock(() => {}),
    },
    event: {
-      findUnique: vi.fn(),
-      findMany: vi.fn(),
+      findUnique: mock(() => {}),
+      findMany: mock(() => {}),
    },
  },
 }));
@@ -61,16 +61,16 @@ const createMockTournament = (id: number, ownerId: string | null): Event => ({

 describe('Tournament Permissions', () => {
  beforeEach(() => {
-    vi.clearAllMocks();
+    mock.clearAllMocks();
  });

  describe('canManageTournament', () => {
    test('should allow club_admin to manage any tournament', async () => {
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
        user: { id: 'admin-1', email: 'admin@example.com' },
        session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(
+      }));
+      prisma.user.findUnique.mockImplementation(async () => 
        createMockUser('admin-1', 'admin@example.com', 'club_admin')
      );

@@ -79,14 +79,14 @@ describe('Tournament Permissions', () => {
    });

    test('should allow tournament_admin to manage their own tournament', async () => {
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
        user: { id: 'tour-admin-1', email: 'tour@example.com' },
        session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(
+      }));
+      prisma.user.findUnique.mockImplementation(async () => 
        createMockUser('tour-admin-1', 'tour@example.com', 'tournament_admin')
      );
-      vi.mocked(prisma.event.findUnique).mockResolvedValue(
+      prisma.event.findUnique.mockImplementation(async () => 
        createMockTournament(1, 'tour-admin-1')
      );

@@ -95,14 +95,14 @@ describe('Tournament Permissions', () => {
    });

    test('should deny tournament_admin from managing other users tournaments', async () => {
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
        user: { id: 'tour-admin-1', email: 'tour@example.com' },
        session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(
+      }));
+      prisma.user.findUnique.mockImplementation(async () => 
        createMockUser('tour-admin-1', 'tour@example.com', 'tournament_admin')
      );
-      vi.mocked(prisma.event.findUnique).mockResolvedValue(
+      prisma.event.findUnique.mockImplementation(async () => 
        createMockTournament(1, 'other-user-1')
      );

@@ -112,11 +112,11 @@ describe('Tournament Permissions', () => {
    });

    test('should deny player from managing tournaments', async () => {
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
        user: { id: 'player-1', email: 'player@example.com' },
        session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(
+      }));
+      prisma.user.findUnique.mockImplementation(async () => 
        createMockUser('player-1', 'player@example.com', 'player')
      );

@@ -126,7 +126,7 @@ describe('Tournament Permissions', () => {
    });

    test('should deny unauthenticated user', async () => {
-      vi.mocked(getSession).mockResolvedValue(null);
+      getSession.mockImplementation(async () => null);

      const result = await canManageTournament(999);
      expect(result.allowed).toBe(false);
@@ -136,11 +136,11 @@ describe('Tournament Permissions', () => {

  describe('ownsTournament', () => {
    test('should return true if user owns tournament', async () => {
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
        user: { id: 'owner-1', email: 'owner@example.com' },
        session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.event.findUnique).mockResolvedValue(
+      }));
+      prisma.event.findUnique.mockImplementation(async () => 
        createMockTournament(1, 'owner-1')
      );

@@ -149,11 +149,11 @@ describe('Tournament Permissions', () => {
    });

    test('should return false if user does not own tournament', async () => {
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
        user: { id: 'non-owner-1', email: 'nonowner@example.com' },
        session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.event.findUnique).mockResolvedValue(
+      }));
+      prisma.event.findUnique.mockImplementation(async () => 
        createMockTournament(1, 'owner-1')
      );

@@ -165,11 +165,11 @@ describe('Tournament Permissions', () => {

  describe('getManageableTournaments', () => {
    test('should return all tournaments for club_admin', async () => {
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
        user: { id: 'admin-1', email: 'admin@example.com' },
        session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(
+      }));
+      prisma.user.findUnique.mockImplementation(async () => 
        createMockUser('admin-1', 'admin@example.com', 'club_admin')
      );
      
@@ -178,7 +178,7 @@ describe('Tournament Permissions', () => {
        createMockTournament(2, 'user-2'),
        createMockTournament(3, 'user-3'),
      ];
-      vi.mocked(prisma.event.findMany).mockResolvedValue(mockTournaments);
+      prisma.event.findMany.mockImplementation(async () => mockTournaments);

      const result = await getManageableTournaments();
      expect(result).toEqual(mockTournaments);
@@ -190,11 +190,11 @@ describe('Tournament Permissions', () => {
    });

    test('should return only owned tournaments for tournament_admin', async () => {
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
        user: { id: 'tour-admin-1', email: 'tour@example.com' },
        session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(
+      }));
+      prisma.user.findUnique.mockImplementation(async () => 
        createMockUser('tour-admin-1', 'tour@example.com', 'tournament_admin')
      );
      
@@ -202,7 +202,7 @@ describe('Tournament Permissions', () => {
        createMockTournament(1, 'tour-admin-1'),
        createMockTournament(2, 'tour-admin-1'),
      ];
-      vi.mocked(prisma.event.findMany).mockResolvedValue(mockTournaments);
+      prisma.event.findMany.mockImplementation(async () => mockTournaments);

      const result = await getManageableTournaments();
      expect(result).toEqual(mockTournaments);
@@ -217,11 +217,11 @@ describe('Tournament Permissions', () => {
    });

    test('should return only non-draft tournaments for players', async () => {
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
        user: { id: 'player-1', email: 'player@example.com' },
        session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(
+      }));
+      prisma.user.findUnique.mockImplementation(async () => 
        createMockUser('player-1', 'player@example.com', 'player')
      );
      
@@ -229,7 +229,7 @@ describe('Tournament Permissions', () => {
        createMockTournament(1, 'user-1'),
        createMockTournament(2, 'user-2'),
      ];
-      vi.mocked(prisma.event.findMany).mockResolvedValue(mockTournaments);
+      prisma.event.findMany.mockImplementation(async () => mockTournaments);

      const result = await getManageableTournaments();
      expect(result).toEqual(mockTournaments);
@@ -249,14 +249,14 @@ describe('Tournament Permissions', () => {
      // This simulates the scenario where a tournament_admin user
      // clicks "Edit" on a tournament they own
      
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
        user: { id: 'tour-admin-1', email: 'tour@example.com' },
        session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(
+      }));
+      prisma.user.findUnique.mockImplementation(async () => 
        createMockUser('tour-admin-1', 'tour@example.com', 'tournament_admin')
      );
-      vi.mocked(prisma.event.findUnique).mockResolvedValue(
+      prisma.event.findUnique.mockImplementation(async () => 
        createMockTournament(1, 'tour-admin-1')
      );

@@ -271,11 +271,11 @@ describe('Tournament Permissions', () => {
    test('club_admin should still be able to manage any tournament', async () => {
      // This ensures we didn't break the existing club_admin functionality
      
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
        user: { id: 'club-admin-1', email: 'club@example.com' },
        session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(
+      }));
+      prisma.user.findUnique.mockImplementation(async () => 
        createMockUser('club-admin-1', 'club@example.com', 'club_admin')
      );

@@ -286,11 +286,11 @@ describe('Tournament Permissions', () => {
    test('players should still be denied from managing tournaments', async () => {
      // This ensures we didn't accidentally grant players access
      
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
        user: { id: 'player-1', email: 'player@example.com' },
        session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(
+      }));
+      prisma.user.findUnique.mockImplementation(async () => 
        createMockUser('player-1', 'player@example.com', 'player')
      );

@@ -0,0 +1,200 @@
+/**
+ * Unit tests for tournament update functionality
+ * Tests the allowTies field is properly saved when updating tournaments
+ */
+
+import { describe, it, expect, mock, beforeEach } from 'bun:test';
+import { prisma } from '@/lib/prisma';
+
+// Mock the prisma client
+mock.module('@/lib/prisma', () => ({
+  prisma: {
+    event: {
+      findUnique: mock(() => {}),
+      update: mock(() => {}),
+    },
+  },
+}));
+
+// Mock the permissions module
+mock.module('@/lib/permissions', () => ({
+  canManageTournament: mock(() => {}).mockResolvedValue({ allowed: true }),
+  canDeleteTournament: mock(() => {}).mockResolvedValue({ allowed: true }),
+}));
+
+// Import the route handler after mocking
+import { PUT } from '@/app/api/tournaments/[id]/route';
+
+describe('Tournament Update API', () => {
+  beforeEach(() => {
+    mock.clearAllMocks();
+  });
+
+  it('should update allowTies field when provided', async () => {
+    // Mock existing tournament
+    prisma.event.findUnique.mockImplementation(async () => ({
+      id: 1,
+      name: 'Test Tournament',
+      allowTies: false,
+      targetScore: 5,
+      eventType: 'tournament',
+      format: 'round_robin',
+      status: 'planned',
+      eventDate: null,
+      description: null,
+      maxParticipants: null,
+      ownerId: null,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+      } as any));
+
+    // Mock successful update
+    prisma.event.update.mockImplementation(async () => ({
+      id: 1,
+      name: 'Test Tournament',
+      allowTies: true,
+      targetScore: 5,
+      eventType: 'tournament',
+      format: 'round_robin',
+      status: 'planned',
+      eventDate: null,
+      description: null,
+      maxParticipants: null,
+      ownerId: null,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+      } as any));
+
+    const request = new Request('http://localhost/api/tournaments/1', {
+      method: 'PUT',
+      body: JSON.stringify({
+        name: 'Test Tournament',
+        allowTies: true,
+        targetScore: 5,
+      }),
+    });
+
+    const params = Promise.resolve({ id: '1' });
+    const response = await PUT(request, { params });
+
+    expect(response.status).toBe(200);
+    expect(prisma.event.update).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({
+          allowTies: true,
+        }),
+      })
+    );
+  });
+
+  it('should default allowTies to false when not provided', async () => {
+    // Mock existing tournament
+    prisma.event.findUnique.mockImplementation(async () => ({
+      id: 1,
+      name: 'Test Tournament',
+      allowTies: true,
+      targetScore: 5,
+      eventType: 'tournament',
+      format: 'round_robin',
+      status: 'planned',
+      eventDate: null,
+      description: null,
+      maxParticipants: null,
+      ownerId: null,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+      } as any));
+
+    // Mock successful update
+    prisma.event.update.mockImplementation(async () => ({
+      id: 1,
+      name: 'Test Tournament',
+      allowTies: false,
+      targetScore: 5,
+      eventType: 'tournament',
+      format: 'round_robin',
+      status: 'planned',
+      eventDate: null,
+      description: null,
+      maxParticipants: null,
+      ownerId: null,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+      } as any));
+
+    const request = new Request('http://localhost/api/tournaments/1', {
+      method: 'PUT',
+      body: JSON.stringify({
+        name: 'Test Tournament',
+        targetScore: 5,
+        // allowTies not provided
+      }),
+    });
+
+    const params = Promise.resolve({ id: '1' });
+    const response = await PUT(request, { params });
+
+    expect(response.status).toBe(200);
+    expect(prisma.event.update).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({
+          allowTies: false, // Should default to false
+        }),
+      })
+    );
+  });
+
+  it('should preserve allowTies value when updating other fields', async () => {
+    // Mock existing tournament with allowTies = true
+    prisma.event.findUnique.mockImplementation(async () => ({
+      id: 1,
+      name: 'Test Tournament',
+      allowTies: true,
+      targetScore: 5,
+      eventType: 'tournament',
+      format: 'round_robin',
+      status: 'planned',
+      eventDate: null,
+      description: null,
+      maxParticipants: null,
+      ownerId: null,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+      } as any));
+
+    // Mock successful update
+    prisma.event.update.mockImplementation(async () => ({
+      id: 1,
+      name: 'Updated Tournament Name',
+      allowTies: true,
+      targetScore: 10,
+      eventType: 'tournament',
+      format: 'round_robin',
+      status: 'planned',
+      eventDate: null,
+      description: null,
+      maxParticipants: null,
+      ownerId: null,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+      } as any));
+
+    const request = new Request('http://localhost/api/tournaments/1', {
+      method: 'PUT',
+      body: JSON.stringify({
+        name: 'Updated Tournament Name',
+        allowTies: true,
+        targetScore: 10,
+      }),
+    });
+
+    const params = Promise.resolve({ id: '1' });
+    const response = await PUT(request, { params });
+
+    expect(response.status).toBe(200);
+    const updateCall = prisma.event.update.mock.calls[0][0];
+    expect(updateCall.data.allowTies).toBe(true);
+    expect(updateCall.data.name).toBe('Updated Tournament Name');
+    expect(updateCall.data.targetScore).toBe(10);
+  });
+});
@@ -4,25 +4,25 @@
 * Tests for user name editing and profile management
 */

-import { describe, test, expect, vi, beforeEach } from 'vitest';
+import { describe, test, expect, mock, beforeEach } from 'bun:test';
 import { hasRole } from '@/lib/permissions';
 import { getSession } from '@/lib/auth-simple';
 import { prisma } from '@/lib/prisma';
 import type { User, Player } from '@prisma/client';

 // Mock the getSession and prisma functions
-vi.mock('@/lib/auth-simple', () => ({
-  getSession: vi.fn(),
+mock.module('@/lib/auth-simple', () => ({
+  getSession: mock(() => {}),
 }));

-vi.mock('@/lib/prisma', () => ({
+mock.module('@/lib/prisma', () => ({
  prisma: {
    user: {
-      findUnique: vi.fn(),
-      update: vi.fn(),
+      findUnique: mock(() => {}),
+      update: mock(() => {}),
    },
    player: {
-      findUnique: vi.fn(),
+      findUnique: mock(() => {}),
    },
  },
 }));
@@ -56,16 +56,16 @@ const createMockPlayer = (id: number, name: string): Player => ({

 describe('User Management', () => {
  beforeEach(() => {
-    vi.clearAllMocks();
+    mock.clearAllMocks();
  });

  describe('User Name Editing', () => {
    test('club_admin should be able to edit any user name', async () => {
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
        user: { id: 'admin-1', email: 'admin@example.com' },
        session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(
+        }));
+      prisma.user.findUnique.mockImplementation(async () => 
        createMockUser('admin-1', 'admin@example.com', 'club_admin')
      );

@@ -74,11 +74,11 @@ describe('User Management', () => {
    });

    test('tournament_admin should NOT be able to edit user names', async () => {
-      vi.mocked(getSession).mockResolvedValue({
-        user: { id: 'tour-admin-1', email: 'tour@example.com' },
+      getSession.mockImplementation(async () => ({
+        user: { id: 'admin-1', email: 'admin@example.com' },
        session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(
+        }));
+      prisma.user.findUnique.mockImplementation(async () => 
        createMockUser('tour-admin-1', 'tour@example.com', 'tournament_admin')
      );

@@ -87,11 +87,11 @@ describe('User Management', () => {
    });

    test('player should NOT be able to edit user names', async () => {
-      vi.mocked(getSession).mockResolvedValue({
-        user: { id: 'player-1', email: 'player@example.com' },
+      getSession.mockImplementation(async () => ({
+        user: { id: 'admin-1', email: 'admin@example.com' },
        session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(
+        }));
+      prisma.user.findUnique.mockImplementation(async () => 
        createMockUser('player-1', 'player@example.com', 'player')
      );

@@ -100,7 +100,7 @@ describe('User Management', () => {
    });

    test('unauthenticated user should NOT be able to edit user names', async () => {
-      vi.mocked(getSession).mockResolvedValue(null);
+      getSession.mockImplementation(async () => null);

      const result = await hasRole('club_admin');
      expect(result.allowed).toBe(false);
@@ -111,11 +111,11 @@ describe('User Management', () => {
    test('user should be able to view their own profile', async () => {
      const mockUser = createMockUser('user-1', 'user@example.com', 'player');
      
-      vi.mocked(getSession).mockResolvedValue({
-        user: { id: 'user-1', email: 'user@example.com' },
+      getSession.mockImplementation(async () => ({
+        user: { id: 'admin-1', email: 'admin@example.com' },
        session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(mockUser);
+        }));
+      prisma.user.findUnique.mockImplementation(async () => mockUser);

      // In the actual implementation, this would check if session.user.id === params.id
      const canViewOwnProfile = true; // This logic is in the API route
@@ -126,11 +126,11 @@ describe('User Management', () => {
      const mockAdmin = createMockUser('admin-1', 'admin@example.com', 'club_admin');
      const mockUser = createMockUser('user-1', 'user@example.com', 'player');
      
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
        user: { id: 'admin-1', email: 'admin@example.com' },
        session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique)
+        }));
+      (prisma.user.findUnique)
        .mockResolvedValueOnce(mockAdmin) // For the requesting user
        .mockResolvedValueOnce(mockUser); // For the target user

@@ -142,11 +142,11 @@ describe('User Management', () => {
    test('non-admin should NOT be able to view other user profiles', async () => {
      const mockUser = createMockUser('user-1', 'user@example.com', 'player');
      
-      vi.mocked(getSession).mockResolvedValue({
-        user: { id: 'user-1', email: 'user@example.com' },
+      getSession.mockImplementation(async () => ({
+        user: { id: 'admin-1', email: 'admin@example.com' },
        session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(mockUser);
+        }));
+      prisma.user.findUnique.mockImplementation(async () => mockUser);

      // In the actual implementation, this would check if session.user.id === params.id
      const canViewOtherProfile = false; // This logic is in the API route
@@ -159,11 +159,11 @@ describe('User Management', () => {
      const mockUser = createMockUser('user-1', 'user@example.com', 'club_admin');
      const mockPlayer = createMockPlayer(1, 'Old Name');
      
-      vi.mocked(getSession).mockResolvedValue({
-        user: { id: 'user-1', email: 'user@example.com' },
+      getSession.mockImplementation(async () => ({
+        user: { id: 'admin-1', email: 'admin@example.com' },
        session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(mockUser);
+        }));
+      prisma.user.findUnique.mockImplementation(async () => mockUser);
      
      const updatedUser = {
        ...mockUser,
@@ -171,7 +171,7 @@ describe('User Management', () => {
        player: { ...mockPlayer, name: 'New Name', normalizedName: 'new name' }
      };
      
-      vi.mocked(prisma.user.update).mockResolvedValue(updatedUser);
+      prisma.user.update.mockImplementation(async () => updatedUser);

      // The API route should update both user.name and player.name
      expect(updatedUser.name).toBe('New Name');
@@ -168,13 +168,21 @@ export default function AdminMatchesPage() {
                      {match.team2Score}
                    </td>
                    <td className="px-6 py-4 whitespace-nowrap text-sm text-gray-500">
-                      <button
-                        onClick={() => handleDelete(match.id)}
-                        disabled={deletingId === match.id}
-                        className="text-red-600 hover:text-red-900 disabled:opacity-50"
-                      >
-                        {deletingId === match.id ? "Deleting..." : "Delete"}
-                      </button>
+                      <div className="flex gap-3">
+                        <Link
+                          href={`/matches/${match.id}`}
+                          className="text-blue-600 hover:text-blue-900"
+                        >
+                          View
+                        </Link>
+                        <button
+                          onClick={() => handleDelete(match.id)}
+                          disabled={deletingId === match.id}
+                          className="text-red-600 hover:text-red-900 disabled:opacity-50"
+                        >
+                          {deletingId === match.id ? "Deleting..." : "Delete"}
+                        </button>
+                      </div>
                    </td>
                  </tr>
                ))}
@@ -37,7 +37,7 @@ export default async function EditUserPage({
    where: {
      OR: [
        { user: null },
-        { id: user.playerId || -1 }, // Include the currently associated player if any
+        ...(user.playerId ? [{ id: user.playerId }] : []), // Include the currently associated player if any
      ],
    },
    orderBy: { name: "asc" },
@@ -32,6 +32,10 @@ export async function PUT(
      );
    }

+    // Parse playerId - handle empty string case
+    const parsedPlayerId = playerId ? parseInt(playerId) : undefined;
+    const isValidPlayerId = parsedPlayerId !== undefined && !isNaN(parsedPlayerId);
+
    // Update the user
    const user = await prisma.user.update({
      where: { id },
@@ -39,14 +43,14 @@ export async function PUT(
        email: email || existingUser.email,
        name: name !== undefined ? name : existingUser.name,
        role: role || existingUser.role,
-        playerId: playerId ? parseInt(playerId) : null,
+        playerId: isValidPlayerId ? parsedPlayerId : null,
      },
    });

    // Update the player's user relation if needed
    if (playerId !== undefined) {
      // First, remove user from any existing player
-      if (existingUser.playerId && existingUser.playerId !== parseInt(playerId)) {
+      if (existingUser.playerId && existingUser.playerId !== parsedPlayerId) {
        await prisma.player.update({
          where: { id: existingUser.playerId },
          data: { user: { disconnect: true } },
@@ -54,9 +58,9 @@ export async function PUT(
      }

      // Then, connect user to the new player
-      if (playerId) {
+      if (isValidPlayerId) {
        await prisma.player.update({
-          where: { id: parseInt(playerId) },
+          where: { id: parsedPlayerId! },
          data: { user: { connect: { id: user.id } } },
        });
      }
@@ -86,12 +86,14 @@ export default async function PlayerProfilePage({ params }: PageProps) {
  const totalWins = player.wins
  const winRate = totalGames > 0 ? ((totalWins / totalGames) * 100).toFixed(1) : "0.0"

-  // Get best partnership
+  // Get best partnership based on ELO contribution
+  // Best partner is the one who contributed most to your rating (highest totalEloChange)
+  // Must have played at least 2 games together to be considered
  const bestPartnership = partnershipStats.reduce((best, stat) => {
-    if (stat.gamesPlayed < 3) return best // Need at least 3 games for partnership to be meaningful
-    const currentRate = stat.wins / stat.gamesPlayed
-    const bestRate = best ? best.wins / best.gamesPlayed : 0
-    return currentRate > bestRate ? stat : best
+    if (stat.gamesPlayed < 2) return best // Need at least 2 games for partnership to be meaningful
+    const currentEloChange = stat.totalEloChange
+    const bestEloChange = best ? best.totalEloChange : -Infinity
+    return currentEloChange > bestEloChange ? stat : best
  }, null as (typeof partnershipStats[0] | null))

  return (
@@ -52,6 +52,7 @@ export default function EditTournamentForm({ tournament }: EditTournamentFormPro
          maxParticipants: formData.maxParticipants ? parseInt(formData.maxParticipants) : null,
          eventDate: formData.eventDate ? new Date(formData.eventDate).toISOString() : null,
          targetScore: formData.targetScore ? parseInt(formData.targetScore) : null,
+          allowTies: formData.allowTies,
        }),
      })

@@ -1,20 +1,38 @@
 import { PrismaClient } from '@prisma/client'
-import { PrismaPg } from '@prisma/adapter-pg'
-import pg from 'pg'
-import dotenv from 'dotenv'

 // Load .env file if it exists
-dotenv.config()
+require('dotenv').config()

 const globalForPrisma = globalThis as unknown as {
  prisma: PrismaClient | undefined
 }

-const adapter = new PrismaPg({ connectionString: process.env.DATABASE_URL })
+// Detect database provider from environment (default to sqlite for local development)
+const databaseProvider = process.env.DATABASE_PROVIDER || 'sqlite'
+const databaseUrl = process.env.DATABASE_URL

-// Create PrismaClient with adapter
+// Create PrismaClient with appropriate adapter
 const createPrismaClient = () => {
-  const client = new PrismaClient({ adapter })
+  let client: PrismaClient
+  
+  if (databaseProvider === 'postgresql') {
+    // Validate DATABASE_URL is present for PostgreSQL
+    if (!databaseUrl) {
+      throw new Error(
+        'DATABASE_URL environment variable is required when DATABASE_PROVIDER is set to postgresql. ' +
+        'Current DATABASE_PROVIDER: ' + databaseProvider
+      )
+    }
+    
+    // Use PrismaPg adapter for PostgreSQL
+    const { PrismaPg } = require('@prisma/adapter-pg')
+    const adapter = new PrismaPg({ connectionString: databaseUrl })
+    client = new PrismaClient({ adapter })
+  } else {
+    // No adapter needed for SQLite
+    client = new PrismaClient()
+  }
+  
  return client
 }

@@ -1 +1,62 @@
 import '@testing-library/jest-dom'
+import path from 'path'
+import fs from 'fs'
+
+/**
+ * Vitest Setup File
+ * 
+ * This file runs before each test file in the Vitest environment.
+ * It validates that tests are running against the development database
+ * to prevent accidental data corruption.
+ */
+
+// Load .env file first, then .env.development (which will override .env)
+const envPath = path.resolve(process.cwd(), '.env');
+const envDevPath = path.resolve(process.cwd(), '.env.development');
+
+// Load base .env file
+if (fs.existsSync(envPath)) {
+  require('dotenv').config({ path: envPath });
+}
+
+// Load .env.development file (will override .env settings)
+if (fs.existsSync(envDevPath)) {
+  require('dotenv').config({ path: envDevPath, override: true });
+}
+
+// Check if DATABASE_URL is set and points to dev database
+const databaseUrl = process.env.DATABASE_URL;
+
+if (databaseUrl) {
+  const isDevDatabase = databaseUrl.includes('euchre_camp_dev');
+  const isProductionDatabase = 
+    databaseUrl.includes('euchre_camp') && 
+    !databaseUrl.includes('_dev') &&
+    !databaseUrl.includes('_dev_');
+
+  if (isProductionDatabase) {
+    console.error('');
+    console.error('='.repeat(80));
+    console.error('CRITICAL ERROR: Tests are attempting to run against PRODUCTION database!');
+    console.error('='.repeat(80));
+    console.error('');
+    console.error('Current DATABASE_URL:', databaseUrl);
+    console.error('');
+    console.error('Tests MUST run against the development database (euchre_camp_dev)');
+    console.error('');
+    console.error('To fix this:');
+    console.error('  1. Run: npm run test:run');
+    console.error('  2. Or set: DATABASE_URL environment variable to dev database URL');
+    console.error('  3. Or load .env.development: source .env.development && npm run test:run');
+    console.error('');
+    console.error('Aborting test execution to prevent data corruption.');
+    console.error('');
+    process.exit(1);
+  }
+
+  if (isDevDatabase) {
+    console.log('✓ Tests running against development database (euchre_camp_dev)');
+  }
+} else {
+  console.warn('⚠ No DATABASE_URL set - tests may fail or use unexpected database');
+}
Author	SHA1	Message	Date
david	178aad7884	feat: update CI/CD to use Bun Pull Request / unit-tests (pull_request) Failing after 1m25s Details Pull Request / acceptance-tests (pull_request) Has been skipped Details Pull Request / analyze-bump-type (pull_request) Has been skipped Details - Update Dockerfile to use oven/bun:alpine image - Update PR workflow to use Bun (oven/setup-bun action) - Update Test workflow to use Bun - Update Release workflow to use Bun - Remove test.yml workflow (redundant with PR workflow) - Update Docker build commands to use Bun - Docker build verified working	2026-04-01 00:20:49 -07:00
david	24db43eb7f	feat: migrate from npm to Bun Test / unit-tests (push) Failing after 1m54s Details Pull Request / unit-tests (pull_request) Failing after 1m41s Details Pull Request / acceptance-tests (pull_request) Has been skipped Details Pull Request / analyze-bump-type (pull_request) Has been skipped Details - Install Bun via mise - Update package.json scripts to use Bun - Migrate unit tests from Vitest to Bun test runner - Migrate component tests from Vitest to Bun test runner - Configure Bun with DOM environment for React Testing Library - Keep Playwright for E2E tests (as planned) - 93/100 tests passing (7 flaky tests when running all together, pass individually)	2026-04-01 00:13:15 -07:00
david	1c9f70c3ed	docs: update TODO list with recent fix Test / unit-tests (push) Successful in 2m10s Details Pull Request / unit-tests (pull_request) Successful in 2m4s Details Pull Request / acceptance-tests (pull_request) Failing after 2m0s Details Pull Request / analyze-bump-type (pull_request) Has been skipped Details	2026-03-31 23:45:38 -07:00
david	5caa284b3c	fix: add defensive checks to prisma.ts to prevent build failures Test / unit-tests (push) Has been cancelled Details	2026-03-31 23:44:43 -07:00
Gitea Actions	ec3297befe	chore: bump version to v0.1.3	2026-04-01 06:31:42 +00:00
david	f4aca275de	fix: skip release steps if no version bump commit was made Pull Request / unit-tests (pull_request) Successful in 2m4s Details Pull Request / acceptance-tests (pull_request) Failing after 2m17s Details Pull Request / analyze-bump-type (pull_request) Has been skipped Details Test / unit-tests (push) Successful in 2m38s Details Release / release (push) Failing after 7m25s Details - Set output variable 'committed' in commit step - Add conditional execution to all subsequent steps - Only create tag, build Docker images, and deploy if commit was successful	2026-03-31 23:23:01 -07:00
david	fe133eab99	fix: improve error handling in getCommitsSinceLastTag - Add nested try-catch to handle git log failures - Return empty array if all git attempts fail - Add warning message when commit history cannot be retrieved	2026-03-31 23:22:38 -07:00
david	89d0d08162	fix: add tag existence check in release workflow Test / unit-tests (push) Successful in 2m22s Details - Check if tag already exists before creating it - Skip tag creation if tag already exists	2026-03-31 23:19:31 -07:00
david	fe18a8b9fe	fix: resolve release workflow version bump issues - Fixed bump-version.js to properly handle --yes flag in CI environments - Added check to skip commit if no changes to package.json or CHANGELOG.md - Ensured script exits cleanly after version bump with --yes flag	2026-03-31 23:19:31 -07:00
david	6b9b690947	ci-image-improvements (#18 ) Release / release (push) Failing after 1m7s Details Test / unit-tests (push) Successful in 2m22s Details Reviewed-on: #18 Co-authored-by: David Gwilliam <dhgwilliam@gmail.com> Co-committed-by: David Gwilliam <dhgwilliam@gmail.com>	2026-04-01 06:14:25 +00:00
david	501e1b7e23	fix: version bumping and Docker registry authentication (#17 ) Release / release (push) Failing after 1m9s Details Test / unit-tests (push) Successful in 2m5s Details ## Summary This PR fixes the release workflow to properly handle version bumping on PR merge and uses the new Docker registry authentication secrets. ## Changes ### Release Workflow (release.yml) - Version Bumping: Now automatically bumps version on PR merge - Determines bump type from commit messages (major/minor/patch) - Commits version bump to `package.json` and `CHANGELOG.md` - Creates git tag for the release - Docker Registry Auth: Uses `DOCKER_LOGIN` and `DOCKER_PASSWORD` secrets - Falls back gracefully if secrets are not configured - Tag Handling: Checks if tag exists before creating (prevents failures) ### PR Workflow (pr.yml) - NEW - Runs unit tests on every PR - Analyzes commits to suggest bump type - Comments the suggested bump type on the PR ### Documentation - Added `WORKFLOW_ARCHITECTURE.md` explaining the workflow design ## Workflow Architecture Two-step process: 1. PR Workflow (on PR): Analyzes commits and suggests bump type 2. Release Workflow (on merge): Bumps version, creates tag, builds Docker image ## Benefits 1. No CI Loops: Version bump commits are detected and skipped 2. Clear Communication: PR comments inform developers of version impact 3. Semantic Versioning: Automated adherence to semver rules 4. Traceability: Git tags and changelog reflect all changes ## Testing The new workflows will be tested when this PR is merged. Closes #13 (Add database test safety configuration) Reviewed-on: #17 Co-authored-by: David Gwilliam <dhgwilliam@gmail.com> Co-committed-by: David Gwilliam <dhgwilliam@gmail.com>	2026-04-01 05:03:14 +00:00
david	9768ff3517	fix: handle Docker registry authentication gracefully in release workflow Release / build-and-test (push) Failing after 5m20s Details	2026-03-31 19:37:34 -07:00
david	0343fa91d2	fix: run unit tests on branch commits, skip main branch Release / build-and-test (push) Has been cancelled Details	2026-03-31 19:33:16 -07:00
david	b654571a37	feat: add test workflow for every commit Release / build-and-test (push) Has been cancelled Details Test / safe-acceptance-tests (push) Has been cancelled Details Test / unit-tests (push) Has been cancelled Details	2026-03-31 19:30:14 -07:00
david	0090611994	trigger: release with test-capable image Release / build-and-test (push) Has been cancelled Details	2026-03-31 19:28:10 -07:00
david	9416159712	feat: build test-capable image, run tests, then build production image Release / build-and-test (push) Has been cancelled Details	2026-03-31 19:27:59 -07:00
david	d39172ca44	trigger: release workflow Release / release (push) Has been cancelled Details	2026-03-31 19:18:13 -07:00
david	cd119694ed	fix: release workflow should not commit, only tag Release / release (push) Has been cancelled Details	2026-03-31 19:18:00 -07:00
david	3e4e896677	trigger: manual workflow trigger for docker.notsosm.art Release / release (push) Has been cancelled Details	2026-03-31 19:16:24 -07:00
david	5e2dbbc2be	fix: update Docker build script to use docker.notsosm.art registry Release / release (push) Has been cancelled Details	2026-03-31 19:16:15 -07:00
david	da9c6ae70b	fix: update workflow to use docker.notsosm.art registry	2026-03-31 19:16:01 -07:00
david	8cf3f2d401	trigger: manual workflow trigger Release / release (push) Failing after 11m46s Details	2026-03-31 18:57:22 -07:00
david	69abec3b87	fix: update workflow to use correct Docker registries Release / release (push) Has been cancelled Details	2026-03-31 18:56:11 -07:00
david	92c064c264	feat: add Gitea Actions release workflow Release / release (push) Has been cancelled Details	2026-03-31 18:55:11 -07:00
david	59009f0bf7	feat: add view match link to admin matches page	2026-03-31 18:52:06 -07:00
david	381bf630c7	chore: bump version to v0.1.1	2026-03-31 18:44:33 -07:00
david	1f4bdc2756	Merge branch 'feat/database-test-safety' of ssh://git.notsosm.art/david/euchre_camp	2026-03-31 18:44:08 -07:00
david	f9d6321721	fix: use ELO change instead of win rate for best partner calculation	2026-03-31 18:39:27 -07:00
david	b38b88f67d	chore: regenerate docker-compose files with environment variables	2026-03-31 18:33:51 -07:00
david	237f128779	fix: remove hardcoded passwords from docker-compose generation	2026-03-31 18:32:32 -07:00
david	6989decf6f	fix: load .env.development in test setup files	2026-03-31 18:30:19 -07:00
david	4e112c92ae	fix: remove hardcoded database URLs and use environment variables	2026-03-31 18:28:17 -07:00
david	a9fc5c312a	fix: set DATABASE_URL for acceptance tests	2026-03-31 18:24:53 -07:00
david	abc1963aea	feat: add database test safety configuration	2026-03-31 18:23:47 -07:00
david	6cef0ac342	chore: update admin script to set site_admin role by default	2026-03-31 17:52:46 -07:00
david	74e6180a35	chore: update Docker repository from dhg.lol:5000 to euchre-camp/euchre-camp	2026-03-31 17:43:12 -07:00
david	8440962649	chore: release v0.1.0 - Update docker-compose files to use v0.1.0 image tag - Add CHANGELOG.md with release notes	2026-03-31 17:33:58 -07:00
david	255b330695	fix: allowTies not saved when editing tournaments (closes #6 ) Fix the allowTies checkbox not being saved when editing tournaments. Added comprehensive unit and E2E tests to verify the fix. Co-authored-by: David Gwilliam <dhgwilliam@gmail.com> Co-committed-by: David Gwilliam <dhgwilliam@gmail.com>	2026-04-01 00:20:25 +00:00
david	8c9a8b0d9f	chore: update cleanup scripts to delete Home Match Player and Admin User patterns	2026-03-31 17:02:22 -07:00
david	a82ec3c9fc	chore: add production database cleanup scripts	2026-03-31 16:57:36 -07:00
david	b5af4b2e34	docs: add development database and testing documentation	2026-03-31 16:53:42 -07:00
david	26c5158724	feat: set up development database and test cleanup utilities	2026-03-31 16:52:56 -07:00
david	48a96ce65f	fix: improve availablePlayers query to handle undefined playerId	2026-03-31 16:44:48 -07:00
david	1f9f708f19	fix: handle empty playerId string in user edit API	2026-03-31 16:44:26 -07:00