commit c48bfe7a896474515a0d8cb84e943d2d80d211d0 · bretton.dev/coves

-1

.claude/commands/create-pr.md

···

       4
       4
        
       

     

       5
       5
        
       ## Behavior

     

       6
       6
        
       - Creates a new branch based on current changes

     

       7
       7
       -
       - Formats modified files using Biome

     

       8
       7
        
       - Analyzes changes and automatically splits into logical commits when appropriate

     

       9
       8
        
       - Each commit focuses on a single logical change or feature

     

       10
       9
        
       - Creates descriptive commit messages for each logical unit

+16

.env.dev

···

       57
       57
        
       POSTGRES_TEST_PORT=5434

     

       58
       58
        
       

     

       59
       59
        
       # =============================================================================

     

       60
       60
       +
       # Jetstream Configuration (Read-Forward User Indexing)

     

       61
       61
       +
       # =============================================================================

     

       62
       62
       +
       # Jetstream WebSocket URL for real-time atProto events

     

       63
       63
       +
       #

     

       64
       64
       +
       # Production: Use Bluesky's public Jetstream (indexes entire network)

     

       65
       65
       +
       # JETSTREAM_URL=wss://jetstream2.us-east.bsky.network/subscribe?wantedCollections=app.bsky.actor.profile

     

       66
       66
       +
       #

     

       67
       67
       +
       # Local E2E Testing: Use local Jetstream (indexes only local PDS)

     

       68
       68
       +
       # 1. Start local Jetstream: docker-compose --profile jetstream up pds jetstream

     

       69
       69
       +
       # 2. Use this URL:

     

       70
       70
       +
       JETSTREAM_URL=ws://localhost:6008/subscribe

     

       71
       71
       +
       

     

       72
       72
       +
       # Optional: Filter events to specific PDS

     

       73
       73
       +
       # JETSTREAM_PDS_FILTER=http://localhost:3001

     

       74
       74
       +
       

     

       75
       75
       +
       # =============================================================================

     

       60
       76
        
       # Development Settings

     

       61
       77
        
       # =============================================================================

     

       62
       78
        
       # Environment

+27 -8

Makefile

···

       1
       1
       -
       .PHONY: help dev-up dev-down dev-logs dev-status dev-reset dev-db-up dev-db-down dev-db-reset test clean

     

       1
       1
       +
       .PHONY: help dev-up dev-down dev-logs dev-status dev-reset test e2e-test clean

     

       2
       2
        
       

     

       3
       3
        
       # Default target - show help

     

       4
       4
        
       .DEFAULT_GOAL := help

     
···

       26
       26
        
       

     

       27
       27
        
       ##@ Local Development (All-in-One)

     

       28
       28
        
       

     

       29
       29
       -
       dev-up: ## Start PDS + PostgreSQL for local development

     

       29
       29
       +
       dev-up: ## Start PDS + PostgreSQL + Jetstream for local development

     

       30
       30
        
       	@echo "$(GREEN)Starting Coves development stack...$(RESET)"

     

       31
       31
       -
       	@docker-compose -f docker-compose.dev.yml --env-file .env.dev up -d postgres pds

     

       31
       31
       +
       	@docker-compose -f docker-compose.dev.yml --env-file .env.dev --profile jetstream up -d postgres pds jetstream

     

       32
       32
        
       	@echo ""

     

       33
       33
        
       	@echo "$(GREEN)✓ Development stack started!$(RESET)"

     

       34
       34
        
       	@echo ""

     

       35
       35
        
       	@echo "Services available at:"

     

       36
       36
        
       	@echo "  - PostgreSQL:        localhost:5433"

     

       37
       37
        
       	@echo "  - PDS (XRPC):        http://localhost:3001"

     

       38
       38
       -
       	@echo "  - PDS Firehose (WS): ws://localhost:3001/xrpc/com.atproto.sync.subscribeRepos"

     

       39
       39
       -
       	@echo "  - AppView (API):     http://localhost:8081 (when uncommented)"

     

       38
       38
       +
       	@echo "  - PDS Firehose:      ws://localhost:3001/xrpc/com.atproto.sync.subscribeRepos"

     

       39
       39
       +
       	@echo "  - Jetstream:         ws://localhost:6008/subscribe  $(CYAN)(Read-Forward)$(RESET)"

     

       40
       40
       +
       	@echo "  - Jetstream Metrics: http://localhost:6009/metrics"

     

       41
       41
       +
       	@echo ""

     

       42
       42
       +
       	@echo "$(CYAN)Next steps:$(RESET)"

     

       43
       43
       +
       	@echo "  1. Run: make run  (starts AppView)"

     

       44
       44
       +
       	@echo "  2. AppView will auto-index users from Jetstream"

     

       40
       45
        
       	@echo ""

     

       41
       46
        
       	@echo "Run 'make dev-logs' to view logs"

     

       42
       47
        
       

     
···

       90
       95
        
       

     

       91
       96
        
       ##@ Testing

     

       92
       97
        
       

     

       93
       93
       -
       test: ## Run all tests with test database

     

       98
       98
       +
       test: ## Run fast unit/integration tests (skips slow E2E tests)

     

       94
       99
        
       	@echo "$(GREEN)Starting test database...$(RESET)"

     

       95
       100
        
       	@docker-compose -f docker-compose.dev.yml --env-file .env.dev --profile test up -d postgres-test

     

       96
       101
        
       	@echo "Waiting for test database to be ready..."

     

       97
       102
        
       	@sleep 3

     

       98
       103
        
       	@echo "$(GREEN)Running migrations on test database...$(RESET)"

     

       99
       104
        
       	@goose -dir internal/db/migrations postgres "postgresql://$(POSTGRES_TEST_USER):$(POSTGRES_TEST_PASSWORD)@localhost:$(POSTGRES_TEST_PORT)/$(POSTGRES_TEST_DB)?sslmode=disable" up || true

     

       100
       100
       -
       	@echo "$(GREEN)Running tests...$(RESET)"

     

       101
       101
       -
       	@go test ./... -v

     

       105
       105
       +
       	@echo "$(GREEN)Running fast tests (use 'make e2e-test' for E2E tests)...$(RESET)"

     

       106
       106
       +
       	@go test ./... -short -v

     

       102
       107
        
       	@echo "$(GREEN)✓ Tests complete$(RESET)"

     

       108
       108
       +
       

     

       109
       109
       +
       e2e-test: ## Run automated E2E tests (requires: make dev-up + make run in another terminal)

     

       110
       110
       +
       	@echo "$(CYAN)========================================$(RESET)"

     

       111
       111
       +
       	@echo "$(CYAN)  E2E Test: Full User Signup Flow      $(RESET)"

     

       112
       112
       +
       	@echo "$(CYAN)========================================$(RESET)"

     

       113
       113
       +
       	@echo ""

     

       114
       114
       +
       	@echo "$(CYAN)Prerequisites:$(RESET)"

     

       115
       115
       +
       	@echo "  1. Run 'make dev-up' (if not already running)"

     

       116
       116
       +
       	@echo "  2. Run 'make run' in another terminal (AppView must be running)"

     

       117
       117
       +
       	@echo ""

     

       118
       118
       +
       	@echo "$(GREEN)Running E2E tests...$(RESET)"

     

       119
       119
       +
       	@go test ./tests/e2e -run TestE2E_UserSignup -v

     

       120
       120
       +
       	@echo ""

     

       121
       121
       +
       	@echo "$(GREEN)✓ E2E tests complete!$(RESET)"

     

       103
       122
        
       

     

       104
       123
        
       test-db-reset: ## Reset test database

     

       105
       124
        
       	@echo "$(GREEN)Resetting test database...$(RESET)"

+28 -8

cmd/server/main.go

···

       1
       1
        
       package main

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"context"

     

       4
       5
        
       	"database/sql"

     

       5
       6
        
       	"fmt"

     

       6
       7
        
       	"log"

     
···

       17
       18
        
       	"Coves/internal/api/routes"

     

       18
       19
        
       	"Coves/internal/core/users"

     

       19
       20
        
       	postgresRepo "Coves/internal/db/postgres"

     

       21
       21
       +
       	"Coves/internal/jetstream"

     

       20
       22
        
       )

     

       21
       23
        
       

     

       22
       24
        
       func main() {

     
···

       27
       29
        
       		dbURL = "postgres://dev_user:dev_password@localhost:5433/coves_dev?sslmode=disable"

     

       28
       30
        
       	}

     

       29
       31
        
       

     

       30
       30
       -
       	// PDS URL configuration

     

       31
       31
       -
       	pdsURL := os.Getenv("PDS_URL")

     

       32
       32
       -
       	if pdsURL == "" {

     

       33
       33
       -
       		pdsURL = "http://localhost:3001" // Local dev PDS

     

       32
       32
       +
       	// Default PDS URL for this Coves instance (supports self-hosting)

     

       33
       33
       +
       	defaultPDS := os.Getenv("PDS_URL")

     

       34
       34
       +
       	if defaultPDS == "" {

     

       35
       35
       +
       		defaultPDS = "http://localhost:3001" // Local dev PDS

     

       34
       36
        
       	}

     

       35
       37
        
       

     

       36
       38
        
       	db, err := sql.Open("postgres", dbURL)

     
···

       68
       70
        
       

     

       69
       71
        
       	// Initialize repositories and services

     

       70
       72
        
       	userRepo := postgresRepo.NewUserRepository(db)

     

       71
       71
       -
       	userService := users.NewUserService(userRepo, pdsURL)

     

       73
       73
       +
       	userService := users.NewUserService(userRepo, defaultPDS)

     

       72
       74
        
       

     

       73
       73
       -
       	// Mount XRPC routes

     

       74
       74
       -
       	r.Mount("/xrpc/social.coves.actor", routes.UserRoutes(userService))

     

       75
       75
       +
       	// Start Jetstream consumer for read-forward user indexing

     

       76
       76
       +
       	jetstreamURL := os.Getenv("JETSTREAM_URL")

     

       77
       77
       +
       	if jetstreamURL == "" {

     

       78
       78
       +
       		jetstreamURL = "wss://jetstream2.us-east.bsky.network/subscribe?wantedCollections=app.bsky.actor.profile"

     

       79
       79
       +
       	}

     

       80
       80
       +
       

     

       81
       81
       +
       	pdsFilter := os.Getenv("JETSTREAM_PDS_FILTER") // Optional: filter to specific PDS

     

       82
       82
       +
       

     

       83
       83
       +
       	userConsumer := jetstream.NewUserEventConsumer(userService, jetstreamURL, pdsFilter)

     

       84
       84
       +
       	ctx := context.Background()

     

       85
       85
       +
       	go func() {

     

       86
       86
       +
       		if err := userConsumer.Start(ctx); err != nil {

     

       87
       87
       +
       			log.Printf("Jetstream consumer stopped: %v", err)

     

       88
       88
       +
       		}

     

       89
       89
       +
       	}()

     

       90
       90
       +
       

     

       91
       91
       +
       	log.Printf("Started Jetstream consumer: %s", jetstreamURL)

     

       92
       92
       +
       

     

       93
       93
       +
       	// Register XRPC routes

     

       94
       94
       +
       	routes.RegisterUserRoutes(r, userService)

     

       75
       95
        
       

     

       76
       96
        
       	r.Get("/health", func(w http.ResponseWriter, r *http.Request) {

     

       77
       97
        
       		w.WriteHeader(http.StatusOK)

     
···

       84
       104
        
       	}

     

       85
       105
        
       

     

       86
       106
        
       	fmt.Printf("Coves AppView starting on port %s\n", port)

     

       87
       87
       -
       	fmt.Printf("PDS URL: %s\n", pdsURL)

     

       107
       107
       +
       	fmt.Printf("Default PDS: %s\n", defaultPDS)

     

       88
       108
        
       	log.Fatal(http.ListenAndServe(":"+port, r))

     

       89
       109
        
       }

+58

docker-compose.dev.yml

···

       102
       102
        
             timeout: 5s

     

       103
       103
        
             retries: 5

     

       104
       104
        
       

     

       105
       105
       +
         # Jetstream - Consumes PDS firehose and serves JSON WebSocket

     

       106
       106
       +
         # This is the RECOMMENDED approach for local E2E testing

     

       107
       107
       +
         # Jetstream converts raw atProto CBOR firehose to clean JSON events

     

       108
       108
       +
         #

     

       109
       109
       +
         # Flow: PDS firehose → Jetstream (CBOR→JSON) → Your AppView (JSON)

     

       110
       110
       +
         #

     

       111
       111
       +
         # Usage:

     

       112
       112
       +
         #   docker-compose --profile jetstream up pds jetstream

     

       113
       113
       +
         #   Your AppView connects to: ws://localhost:6008/subscribe

     

       114
       114
       +
         #

     

       115
       115
       +
         # Why use Jetstream instead of direct PDS firehose?

     

       116
       116
       +
         #   - PDS emits raw CBOR (binary) - hard to parse

     

       117
       117
       +
         #   - Jetstream converts to clean JSON - easy to consume

     

       118
       118
       +
         #   - Same format as production Bluesky Jetstream

     

       119
       119
       +
         jetstream:

     

       120
       120
       +
           image: ghcr.io/bluesky-social/jetstream:sha-306e463693365e21a5ffd3ec051a5a7920000214

     

       121
       121
       +
           container_name: coves-dev-jetstream

     

       122
       122
       +
           ports:

     

       123
       123
       +
             - "6008:6008"  # Jetstream WebSocket endpoint

     

       124
       124
       +
             - "6009:6009"  # Metrics endpoint

     

       125
       125
       +
           environment:

     

       126
       126
       +
             # Point Jetstream at local PDS firehose

     

       127
       127
       +
             JETSTREAM_WS_URL: ws://pds:3000/xrpc/com.atproto.sync.subscribeRepos

     

       128
       128
       +
       

     

       129
       129
       +
             # Server configuration

     

       130
       130
       +
             JETSTREAM_LISTEN_ADDR: ":6008"

     

       131
       131
       +
             JETSTREAM_METRICS_LISTEN_ADDR: ":6009"

     

       132
       132
       +
       

     

       133
       133
       +
             # Data storage

     

       134
       134
       +
             JETSTREAM_DATA_DIR: /data

     

       135
       135
       +
             JETSTREAM_EVENT_TTL: 24h

     

       136
       136
       +
       

     

       137
       137
       +
             # Set long liveness TTL for local dev (PDS may be quiet for long periods)

     

       138
       138
       +
             JETSTREAM_LIVENESS_TTL: 24h

     

       139
       139
       +
       

     

       140
       140
       +
             # Performance tuning

     

       141
       141
       +
             JETSTREAM_WORKER_COUNT: 10

     

       142
       142
       +
             JETSTREAM_MAX_QUEUE_SIZE: 1000

     

       143
       143
       +
       

     

       144
       144
       +
             # Development settings

     

       145
       145
       +
             LOG_LEVEL: ${LOG_LEVEL:-debug}

     

       146
       146
       +
           volumes:

     

       147
       147
       +
             - jetstream-data:/data

     

       148
       148
       +
           networks:

     

       149
       149
       +
             - coves-dev

     

       150
       150
       +
           depends_on:

     

       151
       151
       +
             pds:

     

       152
       152
       +
               condition: service_healthy

     

       153
       153
       +
           healthcheck:

     

       154
       154
       +
             test: ["CMD", "curl", "-f", "http://localhost:6009/metrics"]

     

       155
       155
       +
             interval: 10s

     

       156
       156
       +
             timeout: 5s

     

       157
       157
       +
             retries: 5

     

       158
       158
       +
           profiles:

     

       159
       159
       +
             - jetstream

     

       160
       160
       +
       

     

       105
       161
        
         # Indigo Relay (BigSky) - OPTIONAL for local dev

     

       106
       162
        
         # WARNING: BigSky is designed to crawl the entire atProto network!

     

       107
       163
        
         # For local dev, consider using direct PDS firehose instead (see AppView config below)

     
···

       196
       252
        
           name: coves-test-postgres-data

     

       197
       253
        
         pds-data:

     

       198
       254
        
           name: coves-dev-pds-data

     

       255
       255
       +
         jetstream-data:

     

       256
       256
       +
           name: coves-dev-jetstream-data

+174

docs/E2E_TESTING.md

···

       1
       1
       +
       # End-to-End Testing Guide

     

       2
       2
       +
       

     

       3
       3
       +
       ## Overview

     

       4
       4
       +
       

     

       5
       5
       +
       Coves supports full E2E testing with a local atProto stack:

     

       6
       6
       +
       

     

       7
       7
       +
       ```

     

       8
       8
       +
       Third-party Client → Coves XRPC → PDS → Jetstream → Coves AppView → PostgreSQL

     

       9
       9
       +
       ```

     

       10
       10
       +
       

     

       11
       11
       +
       **Why Jetstream?**

     

       12
       12
       +
       - PDS emits raw CBOR-encoded firehose (binary, hard to parse)

     

       13
       13
       +
       - Jetstream converts CBOR → clean JSON (same format as production)

     

       14
       14
       +
       - Tests exactly match production behavior

     

       15
       15
       +
       

     

       16
       16
       +
       ---

     

       17
       17
       +
       

     

       18
       18
       +
       ## Quick Start

     

       19
       19
       +
       

     

       20
       20
       +
       ### 1. Start Development Stack

     

       21
       21
       +
       

     

       22
       22
       +
       ```bash

     

       23
       23
       +
       make dev-up

     

       24
       24
       +
       ```

     

       25
       25
       +
       

     

       26
       26
       +
       This starts:

     

       27
       27
       +
       - **PostgreSQL** (port 5433) - Coves database

     

       28
       28
       +
       - **PDS** (port 3001) - Local atProto server

     

       29
       29
       +
       - **Jetstream** (port 6008) - CBOR → JSON converter (always runs for read-forward)

     

       30
       30
       +
       

     

       31
       31
       +
       > **Note:** Jetstream is now part of `dev-up` since read-forward architecture requires it

     

       32
       32
       +
       

     

       33
       33
       +
       ### 2. Start AppView

     

       34
       34
       +
       

     

       35
       35
       +
       ```bash

     

       36
       36
       +
       # In another terminal

     

       37
       37
       +
       make run  # Starts AppView (auto-runs migrations)

     

       38
       38
       +
       ```

     

       39
       39
       +
       

     

       40
       40
       +
       AppView will connect to `ws://localhost:6008/subscribe` (configured in `.env.dev`)

     

       41
       41
       +
       

     

       42
       42
       +
       ### 3. Run Automated E2E Tests

     

       43
       43
       +
       

     

       44
       44
       +
       ```bash

     

       45
       45
       +
       make e2e-test

     

       46
       46
       +
       ```

     

       47
       47
       +
       

     

       48
       48
       +
       This runs the full test suite:

     

       49
       49
       +
       - Creates accounts via XRPC endpoint

     

       50
       50
       +
       - Verifies PDS account creation

     

       51
       51
       +
       - Validates Jetstream indexing

     

       52
       52
       +
       - Confirms database storage

     

       53
       53
       +
       

     

       54
       54
       +
       ### 4. Manual Testing (Optional)

     

       55
       55
       +
       

     

       56
       56
       +
       #### Create User via Coves XRPC

     

       57
       57
       +
       

     

       58
       58
       +
       ```bash

     

       59
       59
       +
       curl -X POST http://localhost:8081/xrpc/social.coves.actor.signup \

     

       60
       60
       +
         -H "Content-Type: application/json" \

     

       61
       61
       +
         -d '{

     

       62
       62
       +
           "handle": "alice.local.coves.dev",

     

       63
       63
       +
           "email": "alice@test.com",

     

       64
       64
       +
           "password": "test1234"

     

       65
       65
       +
         }'

     

       66
       66
       +
       ```

     

       67
       67
       +
       

     

       68
       68
       +
       **Response:**

     

       69
       69
       +
       ```json

     

       70
       70
       +
       {

     

       71
       71
       +
         "did": "did:plc:xyz123...",

     

       72
       72
       +
         "handle": "alice.local.coves.dev",

     

       73
       73
       +
         "accessJwt": "eyJ...",

     

       74
       74
       +
         "refreshJwt": "eyJ..."

     

       75
       75
       +
       }

     

       76
       76
       +
       ```

     

       77
       77
       +
       

     

       78
       78
       +
       **What happens:**

     

       79
       79
       +
       1. Coves XRPC handler receives signup request

     

       80
       80
       +
       2. Calls PDS `com.atproto.server.createAccount`

     

       81
       81
       +
       3. PDS creates account → emits to firehose

     

       82
       82
       +
       4. Jetstream converts event → JSON

     

       83
       83
       +
       5. AppView receives JSON → indexes user

     

       84
       84
       +
       6. User appears in PostgreSQL `users` table

     

       85
       85
       +
       

     

       86
       86
       +
       ### 5. Verify Indexing

     

       87
       87
       +
       

     

       88
       88
       +
       Check AppView logs:

     

       89
       89
       +
       ```

     

       90
       90
       +
       2025/01/15 12:00:00 Identity event: did:plc:xyz123 → alice.local.coves.dev

     

       91
       91
       +
       2025/01/15 12:00:00 Indexed new user: alice.local.coves.dev (did:plc:xyz123)

     

       92
       92
       +
       ```

     

       93
       93
       +
       

     

       94
       94
       +
       Query via API:

     

       95
       95
       +
       ```bash

     

       96
       96
       +
       curl "http://localhost:8081/xrpc/social.coves.actor.getProfile?actor=alice.local.coves.dev"

     

       97
       97
       +
       ```

     

       98
       98
       +
       

     

       99
       99
       +
       Expected response:

     

       100
       100
       +
       ```json

     

       101
       101
       +
       {

     

       102
       102
       +
         "did": "did:plc:xyz123...",

     

       103
       103
       +
         "profile": {

     

       104
       104
       +
           "handle": "alice.local.coves.dev",

     

       105
       105
       +
           "createdAt": "2025-01-15T12:00:00Z"

     

       106
       106
       +
         }

     

       107
       107
       +
       }

     

       108
       108
       +
       ```

     

       109
       109
       +
       

     

       110
       110
       +
       ---

     

       111
       111
       +
       

     

       112
       112
       +
       ## Workflow Summary

     

       113
       113
       +
       

     

       114
       114
       +
       ### Daily Development

     

       115
       115
       +
       ```bash

     

       116
       116
       +
       make dev-up    # Start PDS + PostgreSQL + Jetstream (once)

     

       117
       117
       +
       make run       # Start AppView (in another terminal)

     

       118
       118
       +
       make test      # Run fast tests during development

     

       119
       119
       +
       ```

     

       120
       120
       +
       

     

       121
       121
       +
       ### Before Commits/PRs

     

       122
       122
       +
       ```bash

     

       123
       123
       +
       make e2e-test  # Run full E2E test suite

     

       124
       124
       +
       ```

     

       125
       125
       +
       

     

       126
       126
       +
       ### Reset Everything

     

       127
       127
       +
       ```bash

     

       128
       128
       +
       make dev-reset  # Nuclear option - deletes all data

     

       129
       129
       +
       make dev-up     # Start fresh

     

       130
       130
       +
       ```

     

       131
       131
       +
       

     

       132
       132
       +
       ---

     

       133
       133
       +
       

     

       134
       134
       +
       ## Testing Scenarios

     

       135
       135
       +
       

     

       136
       136
       +
       ### Automated E2E Test Suite

     

       137
       137
       +
       

     

       138
       138
       +
       ```bash

     

       139
       139
       +
       make e2e-test

     

       140
       140
       +
       ```

     

       141
       141
       +
       

     

       142
       142
       +
       This tests:

     

       143
       143
       +
       - ✅ Single account creation via XRPC

     

       144
       144
       +
       - ✅ Idempotent duplicate event handling

     

       145
       145
       +
       - ✅ Multiple concurrent user indexing

     

       146
       146
       +
       

     

       147
       147
       +
       ### Manual: User Registration via XRPC

     

       148
       148
       +
       

     

       149
       149
       +
       ```bash

     

       150
       150
       +
       curl -X POST http://localhost:8081/xrpc/social.coves.actor.signup \

     

       151
       151
       +
         -H "Content-Type: application/json" \

     

       152
       152
       +
         -d '{"handle":"bob.local.coves.dev","email":"bob@test.com","password":"pass1234"}'

     

       153
       153
       +
       ```

     

       154
       154
       +
       

     

       155
       155
       +
       ### Manual: Federated User (Direct PDS)

     

       156
       156
       +
       

     

       157
       157
       +
       ```bash

     

       158
       158
       +
       # Simulates a user on another PDS

     

       159
       159
       +
       curl -X POST http://localhost:3001/xrpc/com.atproto.server.createAccount \

     

       160
       160
       +
         -H "Content-Type: application/json" \

     

       161
       161
       +
         -d '{"handle":"charlie.local.coves.dev","email":"charlie@test.com","password":"pass1234"}'

     

       162
       162
       +
       

     

       163
       163
       +
       # Coves AppView will still index via Jetstream (read-forward)

     

       164
       164
       +
       ```

     

       165
       165
       +
       

     

       166
       166
       +
       ---

     

       167
       167
       +
       

     

       168
       168
       +
       ## Next Steps

     

       169
       169
       +
       

     

       170
       170
       +
       1. ✅ E2E testing infrastructure complete

     

       171
       171
       +
       2. ✅ Automated E2E test suite implemented

     

       172
       172
       +
       3. ✅ XRPC signup endpoint for third-party clients

     

       173
       173
       +
       4. 🔨 TODO: Add handle update support

     

       174
       174
       +
       5. 🔨 TODO: Add CI/CD E2E tests

go.mod

···

       25
       25
        
       	github.com/gogo/protobuf v1.3.2 // indirect

     

       26
       26
        
       	github.com/golang/snappy v0.0.4 // indirect

     

       27
       27
        
       	github.com/google/uuid v1.6.0 // indirect

     

       28
       28
       +
       	github.com/gorilla/websocket v1.5.3 // indirect

     

       28
       29
        
       	github.com/hailocab/go-hostpool v0.0.0-20160125115350-e80d13ce29ed // indirect

     

       29
       30
        
       	github.com/hashicorp/go-cleanhttp v0.5.2 // indirect

     

       30
       31
        
       	github.com/hashicorp/go-retryablehttp v0.7.5 // indirect

go.sum

···

       50
       50
        
       github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=

     

       51
       51
        
       github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1 h1:EGx4pi6eqNxGaHF6qqu48+N2wcFQ5qg5FXgOdqsJ5d8=

     

       52
       52
        
       github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=

     

       53
       53
       +
       github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=

     

       54
       54
       +
       github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=

     

       53
       55
        
       github.com/hailocab/go-hostpool v0.0.0-20160125115350-e80d13ce29ed h1:5upAirOpQc1Q53c0bnx2ufif5kANL7bfZWcc6VJWJd8=

     

       54
       56
        
       github.com/hailocab/go-hostpool v0.0.0-20160125115350-e80d13ce29ed/go.mod h1:tMWxXQ9wFIaZeTI9F+hmhFiGpFmhOHzyShyFUhRm0H4=

     

       55
       57
        
       github.com/hashicorp/go-cleanhttp v0.5.2 h1:035FKYIWjmULyFRBKPs8TBQoi0x6d9G4xc9neXJWAZQ=

+104 -5

internal/api/routes/user.go

···

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
        
       	"encoding/json"

     

       5
       5
       +
       	"errors"

     

       5
       6
        
       	"net/http"

     

       6
       7
        
       	"time"

     

       7
       8
        
       

     
···

       21
       22
        
       	}

     

       22
       23
        
       }

     

       23
       24
        
       

     

       24
       24
       -
       // UserRoutes returns user-related XRPC routes

     

       25
       25
       +
       // RegisterUserRoutes registers user-related XRPC endpoints on the router

     

       25
       26
        
       // Implements social.coves.actor.* lexicon endpoints

     

       26
       26
       -
       func UserRoutes(service users.UserService) chi.Router {

     

       27
       27
       +
       func RegisterUserRoutes(r chi.Router, service users.UserService) {

     

       27
       28
        
       	h := NewUserHandler(service)

     

       28
       28
       -
       	r := chi.NewRouter()

     

       29
       29
        
       

     

       30
       30
        
       	// social.coves.actor.getProfile - query endpoint

     

       31
       31
       -
       	r.Get("/profile", h.GetProfile)

     

       31
       31
       +
       	r.Get("/xrpc/social.coves.actor.getProfile", h.GetProfile)

     

       32
       32
        
       

     

       33
       33
       -
       	return r

     

       33
       33
       +
       	// social.coves.actor.signup - procedure endpoint

     

       34
       34
       +
       	r.Post("/xrpc/social.coves.actor.signup", h.Signup)

     

       34
       35
        
       }

     

       35
       36
        
       

     

       36
       37
        
       // GetProfile handles social.coves.actor.getProfile

     
···

       73
       74
        
       	w.Header().Set("Content-Type", "application/json")

     

       74
       75
        
       	w.WriteHeader(http.StatusOK)

     

       75
       76
        
       	json.NewEncoder(w).Encode(response)

     

       77
       77
       +
       }

     

       78
       78
       +
       

     

       79
       79
       +
       // Signup handles social.coves.actor.signup

     

       80
       80
       +
       // Procedure endpoint that registers a new account on the Coves instance

     

       81
       81
       +
       func (h *UserHandler) Signup(w http.ResponseWriter, r *http.Request) {

     

       82
       82
       +
       	ctx := r.Context()

     

       83
       83
       +
       

     

       84
       84
       +
       	// Parse request body

     

       85
       85
       +
       	var req users.RegisterAccountRequest

     

       86
       86
       +
       	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {

     

       87
       87
       +
       		http.Error(w, "invalid request body", http.StatusBadRequest)

     

       88
       88
       +
       		return

     

       89
       89
       +
       	}

     

       90
       90
       +
       

     

       91
       91
       +
       	// Call service to register account

     

       92
       92
       +
       	resp, err := h.userService.RegisterAccount(ctx, req)

     

       93
       93
       +
       	if err != nil {

     

       94
       94
       +
       		// Map service errors to lexicon error types with proper HTTP status codes

     

       95
       95
       +
       		respondWithLexiconError(w, err)

     

       96
       96
       +
       		return

     

       97
       97
       +
       	}

     

       98
       98
       +
       

     

       99
       99
       +
       	// Return response matching lexicon output schema

     

       100
       100
       +
       	response := map[string]interface{}{

     

       101
       101
       +
       		"did":        resp.DID,

     

       102
       102
       +
       		"handle":     resp.Handle,

     

       103
       103
       +
       		"accessJwt":  resp.AccessJwt,

     

       104
       104
       +
       		"refreshJwt": resp.RefreshJwt,

     

       105
       105
       +
       	}

     

       106
       106
       +
       

     

       107
       107
       +
       	w.Header().Set("Content-Type", "application/json")

     

       108
       108
       +
       	w.WriteHeader(http.StatusOK)

     

       109
       109
       +
       	json.NewEncoder(w).Encode(response)

     

       110
       110
       +
       }

     

       111
       111
       +
       

     

       112
       112
       +
       // respondWithLexiconError maps domain errors to lexicon error types and HTTP status codes

     

       113
       113
       +
       // Error names match the lexicon definition in social.coves.actor.signup

     

       114
       114
       +
       func respondWithLexiconError(w http.ResponseWriter, err error) {

     

       115
       115
       +
       	var (

     

       116
       116
       +
       		statusCode int

     

       117
       117
       +
       		errorName  string

     

       118
       118
       +
       		message    string

     

       119
       119
       +
       	)

     

       120
       120
       +
       

     

       121
       121
       +
       	// Map domain errors to lexicon error types

     

       122
       122
       +
       	var invalidHandleErr *users.InvalidHandleError

     

       123
       123
       +
       	var handleNotAvailableErr *users.HandleNotAvailableError

     

       124
       124
       +
       	var invalidInviteCodeErr *users.InvalidInviteCodeError

     

       125
       125
       +
       	var invalidEmailErr *users.InvalidEmailError

     

       126
       126
       +
       	var weakPasswordErr *users.WeakPasswordError

     

       127
       127
       +
       	var pdsErr *users.PDSError

     

       128
       128
       +
       

     

       129
       129
       +
       	switch {

     

       130
       130
       +
       	case errors.As(err, &invalidHandleErr):

     

       131
       131
       +
       		statusCode = http.StatusBadRequest

     

       132
       132
       +
       		errorName = "InvalidHandle"

     

       133
       133
       +
       		message = invalidHandleErr.Error()

     

       134
       134
       +
       

     

       135
       135
       +
       	case errors.As(err, &handleNotAvailableErr):

     

       136
       136
       +
       		statusCode = http.StatusBadRequest

     

       137
       137
       +
       		errorName = "HandleNotAvailable"

     

       138
       138
       +
       		message = handleNotAvailableErr.Error()

     

       139
       139
       +
       

     

       140
       140
       +
       	case errors.As(err, &invalidInviteCodeErr):

     

       141
       141
       +
       		statusCode = http.StatusBadRequest

     

       142
       142
       +
       		errorName = "InvalidInviteCode"

     

       143
       143
       +
       		message = invalidInviteCodeErr.Error()

     

       144
       144
       +
       

     

       145
       145
       +
       	case errors.As(err, &invalidEmailErr):

     

       146
       146
       +
       		statusCode = http.StatusBadRequest

     

       147
       147
       +
       		errorName = "InvalidEmail"

     

       148
       148
       +
       		message = invalidEmailErr.Error()

     

       149
       149
       +
       

     

       150
       150
       +
       	case errors.As(err, &weakPasswordErr):

     

       151
       151
       +
       		statusCode = http.StatusBadRequest

     

       152
       152
       +
       		errorName = "WeakPassword"

     

       153
       153
       +
       		message = weakPasswordErr.Error()

     

       154
       154
       +
       

     

       155
       155
       +
       	case errors.As(err, &pdsErr):

     

       156
       156
       +
       		// PDS errors get mapped based on status code

     

       157
       157
       +
       		statusCode = pdsErr.StatusCode

     

       158
       158
       +
       		errorName = "PDSError"

     

       159
       159
       +
       		message = pdsErr.Message

     

       160
       160
       +
       

     

       161
       161
       +
       	default:

     

       162
       162
       +
       		// Generic error handling (avoid leaking internal details)

     

       163
       163
       +
       		statusCode = http.StatusInternalServerError

     

       164
       164
       +
       		errorName = "InternalServerError"

     

       165
       165
       +
       		message = "An error occurred while processing your request"

     

       166
       166
       +
       	}

     

       167
       167
       +
       

     

       168
       168
       +
       	// XRPC error response format

     

       169
       169
       +
       	w.Header().Set("Content-Type", "application/json")

     

       170
       170
       +
       	w.WriteHeader(statusCode)

     

       171
       171
       +
       	json.NewEncoder(w).Encode(map[string]interface{}{

     

       172
       172
       +
       		"error":   errorName,

     

       173
       173
       +
       		"message": message,

     

       174
       174
       +
       	})

     

       76
       175
        
       }

+57

internal/core/users/errors.go

···

       1
       1
       +
       package users

     

       2
       2
       +
       

     

       3
       3
       +
       import "fmt"

     

       4
       4
       +
       

     

       5
       5
       +
       // Domain errors for user service operations

     

       6
       6
       +
       // These map to lexicon error types defined in social.coves.actor.signup

     

       7
       7
       +
       

     

       8
       8
       +
       type InvalidHandleError struct {

     

       9
       9
       +
       	Handle string

     

       10
       10
       +
       	Reason string

     

       11
       11
       +
       }

     

       12
       12
       +
       

     

       13
       13
       +
       func (e *InvalidHandleError) Error() string {

     

       14
       14
       +
       	return fmt.Sprintf("invalid handle %q: %s", e.Handle, e.Reason)

     

       15
       15
       +
       }

     

       16
       16
       +
       

     

       17
       17
       +
       type HandleNotAvailableError struct {

     

       18
       18
       +
       	Handle string

     

       19
       19
       +
       }

     

       20
       20
       +
       

     

       21
       21
       +
       func (e *HandleNotAvailableError) Error() string {

     

       22
       22
       +
       	return fmt.Sprintf("handle %q is not available", e.Handle)

     

       23
       23
       +
       }

     

       24
       24
       +
       

     

       25
       25
       +
       type InvalidInviteCodeError struct {

     

       26
       26
       +
       	Code string

     

       27
       27
       +
       }

     

       28
       28
       +
       

     

       29
       29
       +
       func (e *InvalidInviteCodeError) Error() string {

     

       30
       30
       +
       	return "invalid or expired invite code"

     

       31
       31
       +
       }

     

       32
       32
       +
       

     

       33
       33
       +
       type InvalidEmailError struct {

     

       34
       34
       +
       	Email string

     

       35
       35
       +
       }

     

       36
       36
       +
       

     

       37
       37
       +
       func (e *InvalidEmailError) Error() string {

     

       38
       38
       +
       	return fmt.Sprintf("invalid email address: %q", e.Email)

     

       39
       39
       +
       }

     

       40
       40
       +
       

     

       41
       41
       +
       type WeakPasswordError struct {

     

       42
       42
       +
       	Reason string

     

       43
       43
       +
       }

     

       44
       44
       +
       

     

       45
       45
       +
       func (e *WeakPasswordError) Error() string {

     

       46
       46
       +
       	return fmt.Sprintf("password does not meet strength requirements: %s", e.Reason)

     

       47
       47
       +
       }

     

       48
       48
       +
       

     

       49
       49
       +
       // PDSError wraps errors from the PDS that we couldn't map to domain errors

     

       50
       50
       +
       type PDSError struct {

     

       51
       51
       +
       	StatusCode int

     

       52
       52
       +
       	Message    string

     

       53
       53
       +
       }

     

       54
       54
       +
       

     

       55
       55
       +
       func (e *PDSError) Error() string {

     

       56
       56
       +
       	return fmt.Sprintf("PDS error (%d): %s", e.StatusCode, e.Message)

     

       57
       57
       +
       }

internal/core/users/interfaces.go

···

       15
       15
        
       	GetUserByDID(ctx context.Context, did string) (*User, error)

     

       16
       16
        
       	GetUserByHandle(ctx context.Context, handle string) (*User, error)

     

       17
       17
        
       	ResolveHandleToDID(ctx context.Context, handle string) (string, error)

     

       18
       18
       +
       	RegisterAccount(ctx context.Context, req RegisterAccountRequest) (*RegisterAccountResponse, error)

     

       18
       19
        
       }

+176 -20

internal/core/users/service.go

···

       1
       1
        
       package users

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"bytes"

     

       4
       5
        
       	"context"

     

       6
       6
       +
       	"encoding/json"

     

       5
       7
        
       	"fmt"

     

       8
       8
       +
       	"io"

     

       9
       9
       +
       	"net/http"

     

       6
       10
        
       	"regexp"

     

       7
       11
        
       	"strings"

     

       12
       12
       +
       	"time"

     

       8
       13
        
       )

     

       9
       14
        
       

     

       10
       10
       -
       // atProto handle validation regex

     

       11
       11
       -
       // Handles must: start/end with alphanumeric, contain only alphanumeric + hyphens, no consecutive hyphens

     

       12
       12
       -
       var handleRegex = regexp.MustCompile(`^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?)*$`)

     

       15
       15
       +
       // atProto handle validation regex (per official atProto spec: https://atproto.com/specs/handle)

     

       16
       16
       +
       // - Must have at least one dot (domain-like structure)

     

       17
       17
       +
       // - Each segment max 63 chars, total max 253 chars

     

       18
       18
       +
       // - Segments: alphanumeric start/end, hyphens allowed in middle

     

       19
       19
       +
       // - TLD (final segment) must start with letter (not digit)

     

       20
       20
       +
       // - Case-insensitive, normalized to lowercase

     

       21
       21
       +
       var handleRegex = regexp.MustCompile(`^([a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$`)

     

       22
       22
       +
       

     

       23
       23
       +
       // Disallowed TLDs per atProto spec

     

       24
       24
       +
       var disallowedTLDs = map[string]bool{

     

       25
       25
       +
       	".alt":       true,

     

       26
       26
       +
       	".arpa":      true,

     

       27
       27
       +
       	".example":   true,

     

       28
       28
       +
       	".internal":  true,

     

       29
       29
       +
       	".invalid":   true,

     

       30
       30
       +
       	".local":     true,

     

       31
       31
       +
       	".localhost": true,

     

       32
       32
       +
       	".onion":     true,

     

       33
       33
       +
       	// .test is allowed for development

     

       34
       34
       +
       }

     

       35
       35
       +
       

     

       36
       36
       +
       const (

     

       37
       37
       +
       	minPasswordLength = 8 // Reasonable minimum, though PDS may enforce stricter rules

     

       38
       38
       +
       	maxHandleLength   = 253

     

       39
       39
       +
       )

     

       13
       40
        
       

     

       14
       41
        
       type userService struct {

     

       15
       15
       -
       	userRepo UserRepository

     

       16
       16
       -
       	pdsURL   string // TODO: Support federated PDS - different users may have different PDS hosts

     

       42
       42
       +
       	userRepo   UserRepository

     

       43
       43
       +
       	defaultPDS string // Default PDS URL for this Coves instance (used when creating new local users via registration API)

     

       17
       44
        
       }

     

       18
       45
        
       

     

       19
       46
        
       // NewUserService creates a new user service

     

       20
       20
       -
       func NewUserService(userRepo UserRepository, pdsURL string) UserService {

     

       47
       47
       +
       func NewUserService(userRepo UserRepository, defaultPDS string) UserService {

     

       21
       48
        
       	return &userService{

     

       22
       22
       -
       		userRepo: userRepo,

     

       23
       23
       -
       		pdsURL:   pdsURL,

     

       49
       49
       +
       		userRepo:   userRepo,

     

       50
       50
       +
       		defaultPDS: defaultPDS,

     

       24
       51
        
       	}

     

       25
       52
        
       }

     

       26
       53
        
       

     

       27
       54
        
       // CreateUser creates a new user in the AppView database

     

       55
       55
       +
       // This method is idempotent: if a user with the same DID already exists, it returns the existing user

     

       28
       56
        
       func (s *userService) CreateUser(ctx context.Context, req CreateUserRequest) (*User, error) {

     

       29
       57
        
       	if err := s.validateCreateRequest(req); err != nil {

     

       30
       58
        
       		return nil, err

     
···

       33
       61
        
       	// Normalize handle

     

       34
       62
        
       	req.Handle = strings.TrimSpace(strings.ToLower(req.Handle))

     

       35
       63
        
       	req.DID = strings.TrimSpace(req.DID)

     

       64
       64
       +
       	req.PDSURL = strings.TrimSpace(req.PDSURL)

     

       36
       65
        
       

     

       37
       66
        
       	user := &User{

     

       38
       67
        
       		DID:    req.DID,

     

       39
       68
        
       		Handle: req.Handle,

     

       69
       69
       +
       		PDSURL: req.PDSURL,

     

       40
       70
        
       	}

     

       41
       71
        
       

     

       42
       42
       -
       	// Repository will handle duplicate constraint errors

     

       43
       43
       -
       	return s.userRepo.Create(ctx, user)

     

       72
       72
       +
       	// Try to create the user

     

       73
       73
       +
       	createdUser, err := s.userRepo.Create(ctx, user)

     

       74
       74
       +
       	if err != nil {

     

       75
       75
       +
       		// If user with this DID already exists, fetch and return it (idempotent behavior)

     

       76
       76
       +
       		if strings.Contains(err.Error(), "user with DID already exists") {

     

       77
       77
       +
       			existingUser, getErr := s.userRepo.GetByDID(ctx, req.DID)

     

       78
       78
       +
       			if getErr != nil {

     

       79
       79
       +
       				return nil, fmt.Errorf("user exists but failed to fetch: %w", getErr)

     

       80
       80
       +
       			}

     

       81
       81
       +
       			return existingUser, nil

     

       82
       82
       +
       		}

     

       83
       83
       +
       		// For other errors (validation, handle conflict, etc.), return the error

     

       84
       84
       +
       		return nil, err

     

       85
       85
       +
       	}

     

       86
       86
       +
       

     

       87
       87
       +
       	return createdUser, nil

     

       44
       88
        
       }

     

       45
       89
        
       

     

       46
       90
        
       // GetUserByDID retrieves a user by their DID

     
···

       81
       125
        
       	return user.DID, nil

     

       82
       126
        
       }

     

       83
       127
        
       

     

       128
       128
       +
       // RegisterAccount creates a new account on the PDS via XRPC

     

       129
       129
       +
       // This is what a UI signup button would call - it handles the PDS account creation

     

       130
       130
       +
       func (s *userService) RegisterAccount(ctx context.Context, req RegisterAccountRequest) (*RegisterAccountResponse, error) {

     

       131
       131
       +
       	if err := s.validateRegisterRequest(req); err != nil {

     

       132
       132
       +
       		return nil, err

     

       133
       133
       +
       	}

     

       134
       134
       +
       

     

       135
       135
       +
       	// Call PDS com.atproto.server.createAccount XRPC endpoint

     

       136
       136
       +
       	pdsURL := strings.TrimSuffix(s.defaultPDS, "/")

     

       137
       137
       +
       	endpoint := fmt.Sprintf("%s/xrpc/com.atproto.server.createAccount", pdsURL)

     

       138
       138
       +
       

     

       139
       139
       +
       	payload := map[string]string{

     

       140
       140
       +
       		"handle":   req.Handle,

     

       141
       141
       +
       		"email":    req.Email,

     

       142
       142
       +
       		"password": req.Password,

     

       143
       143
       +
       	}

     

       144
       144
       +
       	if req.InviteCode != "" {

     

       145
       145
       +
       		payload["inviteCode"] = req.InviteCode

     

       146
       146
       +
       	}

     

       147
       147
       +
       

     

       148
       148
       +
       	jsonData, err := json.Marshal(payload)

     

       149
       149
       +
       	if err != nil {

     

       150
       150
       +
       		return nil, fmt.Errorf("failed to marshal request: %w", err)

     

       151
       151
       +
       	}

     

       152
       152
       +
       

     

       153
       153
       +
       	httpReq, err := http.NewRequestWithContext(ctx, "POST", endpoint, bytes.NewBuffer(jsonData))

     

       154
       154
       +
       	if err != nil {

     

       155
       155
       +
       		return nil, fmt.Errorf("failed to create request: %w", err)

     

       156
       156
       +
       	}

     

       157
       157
       +
       	httpReq.Header.Set("Content-Type", "application/json")

     

       158
       158
       +
       

     

       159
       159
       +
       	// Set timeout to prevent hanging on slow/unavailable PDS

     

       160
       160
       +
       	client := &http.Client{

     

       161
       161
       +
       		Timeout: 10 * time.Second,

     

       162
       162
       +
       	}

     

       163
       163
       +
       	resp, err := client.Do(httpReq)

     

       164
       164
       +
       	if err != nil {

     

       165
       165
       +
       		return nil, fmt.Errorf("failed to call PDS: %w", err)

     

       166
       166
       +
       	}

     

       167
       167
       +
       	defer resp.Body.Close()

     

       168
       168
       +
       

     

       169
       169
       +
       	body, err := io.ReadAll(resp.Body)

     

       170
       170
       +
       	if err != nil {

     

       171
       171
       +
       		return nil, fmt.Errorf("failed to read response: %w", err)

     

       172
       172
       +
       	}

     

       173
       173
       +
       

     

       174
       174
       +
       	if resp.StatusCode != http.StatusOK {

     

       175
       175
       +
       		return nil, fmt.Errorf("PDS returned status %d: %s", resp.StatusCode, string(body))

     

       176
       176
       +
       	}

     

       177
       177
       +
       

     

       178
       178
       +
       	var pdsResp RegisterAccountResponse

     

       179
       179
       +
       	if err := json.Unmarshal(body, &pdsResp); err != nil {

     

       180
       180
       +
       		return nil, fmt.Errorf("failed to parse PDS response: %w", err)

     

       181
       181
       +
       	}

     

       182
       182
       +
       

     

       183
       183
       +
       	// Set the PDS URL in the response (PDS doesn't return this)

     

       184
       184
       +
       	pdsResp.PDSURL = s.defaultPDS

     

       185
       185
       +
       

     

       186
       186
       +
       	return &pdsResp, nil

     

       187
       187
       +
       }

     

       188
       188
       +
       

     

       84
       189
        
       func (s *userService) validateCreateRequest(req CreateUserRequest) error {

     

       85
       190
        
       	if strings.TrimSpace(req.DID) == "" {

     

       86
       191
        
       		return fmt.Errorf("DID is required")

     
···

       88
       193
        
       

     

       89
       194
        
       	if strings.TrimSpace(req.Handle) == "" {

     

       90
       195
        
       		return fmt.Errorf("handle is required")

     

       196
       196
       +
       	}

     

       197
       197
       +
       

     

       198
       198
       +
       	if strings.TrimSpace(req.PDSURL) == "" {

     

       199
       199
       +
       		return fmt.Errorf("PDS URL is required")

     

       91
       200
        
       	}

     

       92
       201
        
       

     

       93
       202
        
       	// DID format validation

     
···

       95
       204
        
       		return fmt.Errorf("invalid DID format: must start with 'did:'")

     

       96
       205
        
       	}

     

       97
       206
        
       

     

       98
       98
       -
       	// atProto handle validation

     

       99
       99
       -
       	handle := strings.TrimSpace(strings.ToLower(req.Handle))

     

       207
       207
       +
       	// Validate handle format

     

       208
       208
       +
       	if err := validateHandle(req.Handle); err != nil {

     

       209
       209
       +
       		return err

     

       210
       210
       +
       	}

     

       100
       211
        
       

     

       101
       101
       -
       	// Length validation (1-253 characters per atProto spec)

     

       102
       102
       -
       	if len(handle) < 1 || len(handle) > 253 {

     

       103
       103
       -
       		return fmt.Errorf("handle must be between 1 and 253 characters")

     

       212
       212
       +
       	return nil

     

       213
       213
       +
       }

     

       214
       214
       +
       

     

       215
       215
       +
       func (s *userService) validateRegisterRequest(req RegisterAccountRequest) error {

     

       216
       216
       +
       	if strings.TrimSpace(req.Handle) == "" {

     

       217
       217
       +
       		return fmt.Errorf("handle is required")

     

       104
       218
        
       	}

     

       105
       219
        
       

     

       106
       106
       -
       	// Regex validation: alphanumeric + hyphens + dots, no consecutive hyphens

     

       220
       220
       +
       	if strings.TrimSpace(req.Email) == "" {

     

       221
       221
       +
       		return &InvalidEmailError{Email: req.Email}

     

       222
       222
       +
       	}

     

       223
       223
       +
       

     

       224
       224
       +
       	// Basic email validation

     

       225
       225
       +
       	if !strings.Contains(req.Email, "@") || !strings.Contains(req.Email, ".") {

     

       226
       226
       +
       		return &InvalidEmailError{Email: req.Email}

     

       227
       227
       +
       	}

     

       228
       228
       +
       

     

       229
       229
       +
       	// Password validation

     

       230
       230
       +
       	if strings.TrimSpace(req.Password) == "" {

     

       231
       231
       +
       		return &WeakPasswordError{Reason: "password is required"}

     

       232
       232
       +
       	}

     

       233
       233
       +
       

     

       234
       234
       +
       	if len(req.Password) < minPasswordLength {

     

       235
       235
       +
       		return &WeakPasswordError{Reason: fmt.Sprintf("password must be at least %d characters", minPasswordLength)}

     

       236
       236
       +
       	}

     

       237
       237
       +
       

     

       238
       238
       +
       	// Validate handle format

     

       239
       239
       +
       	if err := validateHandle(req.Handle); err != nil {

     

       240
       240
       +
       		return err

     

       241
       241
       +
       	}

     

       242
       242
       +
       

     

       243
       243
       +
       	return nil

     

       244
       244
       +
       }

     

       245
       245
       +
       

     

       246
       246
       +
       // validateHandle validates handle per atProto spec: https://atproto.com/specs/handle

     

       247
       247
       +
       func validateHandle(handle string) error {

     

       248
       248
       +
       	// Normalize to lowercase (handles are case-insensitive)

     

       249
       249
       +
       	handle = strings.TrimSpace(strings.ToLower(handle))

     

       250
       250
       +
       

     

       251
       251
       +
       	if handle == "" {

     

       252
       252
       +
       		return &InvalidHandleError{Handle: handle, Reason: "handle cannot be empty"}

     

       253
       253
       +
       	}

     

       254
       254
       +
       

     

       255
       255
       +
       	// Check length

     

       256
       256
       +
       	if len(handle) > maxHandleLength {

     

       257
       257
       +
       		return &InvalidHandleError{Handle: handle, Reason: fmt.Sprintf("handle exceeds maximum length of %d characters", maxHandleLength)}

     

       258
       258
       +
       	}

     

       259
       259
       +
       

     

       260
       260
       +
       	// Check regex pattern

     

       107
       261
        
       	if !handleRegex.MatchString(handle) {

     

       108
       108
       -
       		return fmt.Errorf("invalid handle format: must contain only alphanumeric characters, hyphens, and dots; must start and end with alphanumeric; no consecutive hyphens")

     

       262
       262
       +
       		return &InvalidHandleError{Handle: handle, Reason: "handle must be domain-like (e.g., user.bsky.social), with segments of alphanumeric/hyphens separated by dots"}

     

       109
       263
        
       	}

     

       110
       264
        
       

     

       111
       111
       -
       	// Check for consecutive hyphens (not allowed in atProto)

     

       112
       112
       -
       	if strings.Contains(handle, "--") {

     

       113
       113
       -
       		return fmt.Errorf("invalid handle format: consecutive hyphens not allowed")

     

       265
       265
       +
       	// Check for disallowed TLDs

     

       266
       266
       +
       	for tld := range disallowedTLDs {

     

       267
       267
       +
       		if strings.HasSuffix(handle, tld) {

     

       268
       268
       +
       			return &InvalidHandleError{Handle: handle, Reason: fmt.Sprintf("TLD %s is not allowed", tld)}

     

       269
       269
       +
       		}

     

       114
       270
        
       	}

     

       115
       271
        
       

     

       116
       272
        
       	return nil

+19

internal/core/users/user.go

···

       10
       10
        
       type User struct {

     

       11
       11
        
       	DID       string    `json:"did" db:"did"`           // atProto DID (e.g., did:plc:xyz123)

     

       12
       12
        
       	Handle    string    `json:"handle" db:"handle"`     // Human-readable handle (e.g., alice.coves.dev)

     

       13
       13
       +
       	PDSURL    string    `json:"pdsUrl" db:"pds_url"`    // User's PDS host URL (supports federation)

     

       13
       14
        
       	CreatedAt time.Time `json:"createdAt" db:"created_at"`

     

       14
       15
        
       	UpdatedAt time.Time `json:"updatedAt" db:"updated_at"`

     

       15
       16
        
       }

     
···

       18
       19
        
       type CreateUserRequest struct {

     

       19
       20
        
       	DID    string `json:"did"`

     

       20
       21
        
       	Handle string `json:"handle"`

     

       22
       22
       +
       	PDSURL string `json:"pdsUrl"` // User's PDS host URL

     

       23
       23
       +
       }

     

       24
       24
       +
       

     

       25
       25
       +
       // RegisterAccountRequest represents the input for registering a new account on the PDS

     

       26
       26
       +
       type RegisterAccountRequest struct {

     

       27
       27
       +
       	Handle     string `json:"handle"`

     

       28
       28
       +
       	Email      string `json:"email"`

     

       29
       29
       +
       	Password   string `json:"password"`

     

       30
       30
       +
       	InviteCode string `json:"inviteCode,omitempty"`

     

       31
       31
       +
       }

     

       32
       32
       +
       

     

       33
       33
       +
       // RegisterAccountResponse represents the response from PDS account creation

     

       34
       34
       +
       type RegisterAccountResponse struct {

     

       35
       35
       +
       	DID         string `json:"did"`

     

       36
       36
       +
       	Handle      string `json:"handle"`

     

       37
       37
       +
       	AccessJwt   string `json:"accessJwt"`

     

       38
       38
       +
       	RefreshJwt  string `json:"refreshJwt"`

     

       39
       39
       +
       	PDSURL      string `json:"pdsUrl"`

     

       21
       40
        
       }

+4 -1

internal/db/migrations/001_create_users_table.sql

···

       3
       3
        
       CREATE TABLE users (

     

       4
       4
        
           did TEXT PRIMARY KEY,

     

       5
       5
        
           handle TEXT UNIQUE NOT NULL,

     

       6
       6
       +
           pds_url TEXT NOT NULL CHECK (pds_url <> ''), -- User's PDS host (supports federation)

     

       6
       7
        
           created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,

     

       7
       8
        
           updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP

     

       8
       9
        
       );

     
···

       12
       13
        
       CREATE INDEX idx_users_created_at ON users(created_at);

     

       13
       14
        
       

     

       14
       15
        
       -- +goose Down

     

       15
       15
       -
       DROP TABLE users;

     

       16
       16
       +
       DROP INDEX IF EXISTS idx_users_created_at;

     

       17
       17
       +
       DROP INDEX IF EXISTS idx_users_handle;

     

       18
       18
       +
       DROP TABLE IF EXISTS users;

+9 -9

internal/db/postgres/user_repo.go

···

       21
       21
        
       // Create inserts a new user into the users table

     

       22
       22
        
       func (r *postgresUserRepo) Create(ctx context.Context, user *users.User) (*users.User, error) {

     

       23
       23
        
       	query := `

     

       24
       24
       -
       		INSERT INTO users (did, handle)

     

       25
       25
       -
       		VALUES ($1, $2)

     

       26
       26
       -
       		RETURNING did, handle, created_at, updated_at`

     

       24
       24
       +
       		INSERT INTO users (did, handle, pds_url)

     

       25
       25
       +
       		VALUES ($1, $2, $3)

     

       26
       26
       +
       		RETURNING did, handle, pds_url, created_at, updated_at`

     

       27
       27
        
       

     

       28
       28
       -
       	err := r.db.QueryRowContext(ctx, query, user.DID, user.Handle).

     

       29
       29
       -
       		Scan(&user.DID, &user.Handle, &user.CreatedAt, &user.UpdatedAt)

     

       28
       28
       +
       	err := r.db.QueryRowContext(ctx, query, user.DID, user.Handle, user.PDSURL).

     

       29
       29
       +
       		Scan(&user.DID, &user.Handle, &user.PDSURL, &user.CreatedAt, &user.UpdatedAt)

     

       30
       30
        
       

     

       31
       31
        
       	if err != nil {

     

       32
       32
        
       		// Check for unique constraint violations

     
···

       47
       47
        
       // GetByDID retrieves a user by their DID

     

       48
       48
        
       func (r *postgresUserRepo) GetByDID(ctx context.Context, did string) (*users.User, error) {

     

       49
       49
        
       	user := &users.User{}

     

       50
       50
       -
       	query := `SELECT did, handle, created_at, updated_at FROM users WHERE did = $1`

     

       50
       50
       +
       	query := `SELECT did, handle, pds_url, created_at, updated_at FROM users WHERE did = $1`

     

       51
       51
        
       

     

       52
       52
        
       	err := r.db.QueryRowContext(ctx, query, did).

     

       53
       53
       -
       		Scan(&user.DID, &user.Handle, &user.CreatedAt, &user.UpdatedAt)

     

       53
       53
       +
       		Scan(&user.DID, &user.Handle, &user.PDSURL, &user.CreatedAt, &user.UpdatedAt)

     

       54
       54
        
       

     

       55
       55
        
       	if err == sql.ErrNoRows {

     

       56
       56
        
       		return nil, fmt.Errorf("user not found")

     
···

       65
       65
        
       // GetByHandle retrieves a user by their handle

     

       66
       66
        
       func (r *postgresUserRepo) GetByHandle(ctx context.Context, handle string) (*users.User, error) {

     

       67
       67
        
       	user := &users.User{}

     

       68
       68
       -
       	query := `SELECT did, handle, created_at, updated_at FROM users WHERE handle = $1`

     

       68
       68
       +
       	query := `SELECT did, handle, pds_url, created_at, updated_at FROM users WHERE handle = $1`

     

       69
       69
        
       

     

       70
       70
        
       	err := r.db.QueryRowContext(ctx, query, handle).

     

       71
       71
       -
       		Scan(&user.DID, &user.Handle, &user.CreatedAt, &user.UpdatedAt)

     

       71
       71
       +
       		Scan(&user.DID, &user.Handle, &user.PDSURL, &user.CreatedAt, &user.UpdatedAt)

     

       72
       72
        
       

     

       73
       73
        
       	if err == sql.ErrNoRows {

     

       74
       74
        
       		return nil, fmt.Errorf("user not found")

+254

internal/jetstream/user_consumer.go

···

       1
       1
       +
       package jetstream

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"context"

     

       5
       5
       +
       	"encoding/json"

     

       6
       6
       +
       	"fmt"

     

       7
       7
       +
       	"log"

     

       8
       8
       +
       	"time"

     

       9
       9
       +
       

     

       10
       10
       +
       	"Coves/internal/core/users"

     

       11
       11
       +
       	"github.com/gorilla/websocket"

     

       12
       12
       +
       )

     

       13
       13
       +
       

     

       14
       14
       +
       // JetstreamEvent represents an event from the Jetstream firehose

     

       15
       15
       +
       // Jetstream documentation: https://docs.bsky.app/docs/advanced-guides/jetstream

     

       16
       16
       +
       type JetstreamEvent struct {

     

       17
       17
       +
       	Did    string          `json:"did"`

     

       18
       18
       +
       	TimeUS int64           `json:"time_us"`

     

       19
       19
       +
       	Kind   string          `json:"kind"` // "account", "commit", "identity"

     

       20
       20
       +
       	Account *AccountEvent  `json:"account,omitempty"`

     

       21
       21
       +
       	Identity *IdentityEvent `json:"identity,omitempty"`

     

       22
       22
       +
       }

     

       23
       23
       +
       

     

       24
       24
       +
       type AccountEvent struct {

     

       25
       25
       +
       	Active bool   `json:"active"`

     

       26
       26
       +
       	Did    string `json:"did"`

     

       27
       27
       +
       	Seq    int64  `json:"seq"`

     

       28
       28
       +
       	Time   string `json:"time"`

     

       29
       29
       +
       }

     

       30
       30
       +
       

     

       31
       31
       +
       type IdentityEvent struct {

     

       32
       32
       +
       	Did    string `json:"did"`

     

       33
       33
       +
       	Handle string `json:"handle"`

     

       34
       34
       +
       	Seq    int64  `json:"seq"`

     

       35
       35
       +
       	Time   string `json:"time"`

     

       36
       36
       +
       }

     

       37
       37
       +
       

     

       38
       38
       +
       // UserEventConsumer consumes user-related events from Jetstream

     

       39
       39
       +
       type UserEventConsumer struct {

     

       40
       40
       +
       	userService users.UserService

     

       41
       41
       +
       	wsURL       string

     

       42
       42
       +
       	pdsFilter   string // Optional: only index users from specific PDS

     

       43
       43
       +
       }

     

       44
       44
       +
       

     

       45
       45
       +
       // NewUserEventConsumer creates a new Jetstream consumer for user events

     

       46
       46
       +
       func NewUserEventConsumer(userService users.UserService, wsURL string, pdsFilter string) *UserEventConsumer {

     

       47
       47
       +
       	return &UserEventConsumer{

     

       48
       48
       +
       		userService: userService,

     

       49
       49
       +
       		wsURL:       wsURL,

     

       50
       50
       +
       		pdsFilter:   pdsFilter,

     

       51
       51
       +
       	}

     

       52
       52
       +
       }

     

       53
       53
       +
       

     

       54
       54
       +
       // Start begins consuming events from Jetstream

     

       55
       55
       +
       // Runs indefinitely, reconnecting on errors

     

       56
       56
       +
       func (c *UserEventConsumer) Start(ctx context.Context) error {

     

       57
       57
       +
       	log.Printf("Starting Jetstream user consumer: %s", c.wsURL)

     

       58
       58
       +
       

     

       59
       59
       +
       	for {

     

       60
       60
       +
       		select {

     

       61
       61
       +
       		case <-ctx.Done():

     

       62
       62
       +
       			log.Println("Jetstream consumer shutting down")

     

       63
       63
       +
       			return ctx.Err()

     

       64
       64
       +
       		default:

     

       65
       65
       +
       			if err := c.connect(ctx); err != nil {

     

       66
       66
       +
       				log.Printf("Jetstream connection error: %v. Retrying in 5s...", err)

     

       67
       67
       +
       				time.Sleep(5 * time.Second)

     

       68
       68
       +
       				continue

     

       69
       69
       +
       			}

     

       70
       70
       +
       		}

     

       71
       71
       +
       	}

     

       72
       72
       +
       }

     

       73
       73
       +
       

     

       74
       74
       +
       // connect establishes WebSocket connection and processes events

     

       75
       75
       +
       func (c *UserEventConsumer) connect(ctx context.Context) error {

     

       76
       76
       +
       	conn, _, err := websocket.DefaultDialer.DialContext(ctx, c.wsURL, nil)

     

       77
       77
       +
       	if err != nil {

     

       78
       78
       +
       		return fmt.Errorf("failed to connect to Jetstream: %w", err)

     

       79
       79
       +
       	}

     

       80
       80
       +
       	defer conn.Close()

     

       81
       81
       +
       

     

       82
       82
       +
       	log.Println("Connected to Jetstream")

     

       83
       83
       +
       

     

       84
       84
       +
       	// Set read deadline to detect connection issues

     

       85
       85
       +
       	conn.SetReadDeadline(time.Now().Add(60 * time.Second))

     

       86
       86
       +
       

     

       87
       87
       +
       	// Set pong handler to keep connection alive

     

       88
       88
       +
       	conn.SetPongHandler(func(string) error {

     

       89
       89
       +
       		conn.SetReadDeadline(time.Now().Add(60 * time.Second))

     

       90
       90
       +
       		return nil

     

       91
       91
       +
       	})

     

       92
       92
       +
       

     

       93
       93
       +
       	// Start ping ticker

     

       94
       94
       +
       	ticker := time.NewTicker(30 * time.Second)

     

       95
       95
       +
       	defer ticker.Stop()

     

       96
       96
       +
       

     

       97
       97
       +
       	done := make(chan struct{})

     

       98
       98
       +
       

     

       99
       99
       +
       	// Goroutine to send pings

     

       100
       100
       +
       	// TODO: Fix race condition - multiple goroutines can call close(done) concurrently

     

       101
       101
       +
       	// Use sync.Once to ensure close(done) is called exactly once

     

       102
       102
       +
       	// See PR review issue #4

     

       103
       103
       +
       	go func() {

     

       104
       104
       +
       		for {

     

       105
       105
       +
       			select {

     

       106
       106
       +
       			case <-ticker.C:

     

       107
       107
       +
       				if err := conn.WriteMessage(websocket.PingMessage, nil); err != nil {

     

       108
       108
       +
       					log.Printf("Ping error: %v", err)

     

       109
       109
       +
       					close(done)

     

       110
       110
       +
       					return

     

       111
       111
       +
       				}

     

       112
       112
       +
       			case <-done:

     

       113
       113
       +
       				return

     

       114
       114
       +
       			case <-ctx.Done():

     

       115
       115
       +
       				return

     

       116
       116
       +
       			}

     

       117
       117
       +
       		}

     

       118
       118
       +
       	}()

     

       119
       119
       +
       

     

       120
       120
       +
       	// Read messages

     

       121
       121
       +
       	for {

     

       122
       122
       +
       		select {

     

       123
       123
       +
       		case <-ctx.Done():

     

       124
       124
       +
       			return ctx.Err()

     

       125
       125
       +
       		case <-done:

     

       126
       126
       +
       			return fmt.Errorf("connection closed")

     

       127
       127
       +
       		default:

     

       128
       128
       +
       			_, message, err := conn.ReadMessage()

     

       129
       129
       +
       			if err != nil {

     

       130
       130
       +
       				close(done)

     

       131
       131
       +
       				return fmt.Errorf("read error: %w", err)

     

       132
       132
       +
       			}

     

       133
       133
       +
       

     

       134
       134
       +
       			// Reset read deadline on successful read

     

       135
       135
       +
       			conn.SetReadDeadline(time.Now().Add(60 * time.Second))

     

       136
       136
       +
       

     

       137
       137
       +
       			if err := c.handleEvent(ctx, message); err != nil {

     

       138
       138
       +
       				log.Printf("Error handling event: %v", err)

     

       139
       139
       +
       				// Continue processing other events

     

       140
       140
       +
       			}

     

       141
       141
       +
       		}

     

       142
       142
       +
       	}

     

       143
       143
       +
       }

     

       144
       144
       +
       

     

       145
       145
       +
       // handleEvent processes a single Jetstream event

     

       146
       146
       +
       func (c *UserEventConsumer) handleEvent(ctx context.Context, data []byte) error {

     

       147
       147
       +
       	var event JetstreamEvent

     

       148
       148
       +
       	if err := json.Unmarshal(data, &event); err != nil {

     

       149
       149
       +
       		return fmt.Errorf("failed to parse event: %w", err)

     

       150
       150
       +
       	}

     

       151
       151
       +
       

     

       152
       152
       +
       	// We're interested in identity events (handle updates) and account events (new users)

     

       153
       153
       +
       	switch event.Kind {

     

       154
       154
       +
       	case "identity":

     

       155
       155
       +
       		return c.handleIdentityEvent(ctx, &event)

     

       156
       156
       +
       	case "account":

     

       157
       157
       +
       		return c.handleAccountEvent(ctx, &event)

     

       158
       158
       +
       	default:

     

       159
       159
       +
       		// Ignore other event types (commits, etc.)

     

       160
       160
       +
       		return nil

     

       161
       161
       +
       	}

     

       162
       162
       +
       }

     

       163
       163
       +
       

     

       164
       164
       +
       // HandleIdentityEventPublic is a public wrapper for testing

     

       165
       165
       +
       func (c *UserEventConsumer) HandleIdentityEventPublic(ctx context.Context, event *JetstreamEvent) error {

     

       166
       166
       +
       	return c.handleIdentityEvent(ctx, event)

     

       167
       167
       +
       }

     

       168
       168
       +
       

     

       169
       169
       +
       // handleIdentityEvent processes identity events (handle changes)

     

       170
       170
       +
       func (c *UserEventConsumer) handleIdentityEvent(ctx context.Context, event *JetstreamEvent) error {

     

       171
       171
       +
       	if event.Identity == nil {

     

       172
       172
       +
       		return fmt.Errorf("identity event missing identity data")

     

       173
       173
       +
       	}

     

       174
       174
       +
       

     

       175
       175
       +
       	did := event.Identity.Did

     

       176
       176
       +
       	handle := event.Identity.Handle

     

       177
       177
       +
       

     

       178
       178
       +
       	if did == "" || handle == "" {

     

       179
       179
       +
       		return fmt.Errorf("identity event missing did or handle")

     

       180
       180
       +
       	}

     

       181
       181
       +
       

     

       182
       182
       +
       	log.Printf("Identity event: %s → %s", did, handle)

     

       183
       183
       +
       

     

       184
       184
       +
       	// For now, we'll create/update user on identity events

     

       185
       185
       +
       	// In a full implementation, you'd want to:

     

       186
       186
       +
       	// 1. Check if user exists

     

       187
       187
       +
       	// 2. Update handle if changed

     

       188
       188
       +
       	// 3. Resolve PDS URL from DID document

     

       189
       189
       +
       

     

       190
       190
       +
       	// Simplified: just try to create user (will be idempotent)

     

       191
       191
       +
       	// We need PDS URL - for now use a placeholder

     

       192
       192
       +
       	// TODO: Implement DID→PDS resolution via PLC directory (https://plc.directory/{did})

     

       193
       193
       +
       	// For production federation support, resolve PDS endpoint from DID document

     

       194
       194
       +
       	// For local dev, this works fine since we filter to our own PDS

     

       195
       195
       +
       	// See PR review issue #2

     

       196
       196
       +
       	pdsURL := "https://bsky.social" // Default Bluesky PDS

     

       197
       197
       +
       

     

       198
       198
       +
       	_, err := c.userService.CreateUser(ctx, users.CreateUserRequest{

     

       199
       199
       +
       		DID:    did,

     

       200
       200
       +
       		Handle: handle,

     

       201
       201
       +
       		PDSURL: pdsURL,

     

       202
       202
       +
       	})

     

       203
       203
       +
       

     

       204
       204
       +
       	if err != nil {

     

       205
       205
       +
       		// Check if it's a duplicate error (expected for idempotency)

     

       206
       206
       +
       		if isDuplicateError(err) {

     

       207
       207
       +
       			log.Printf("User already indexed: %s (%s)", handle, did)

     

       208
       208
       +
       			return nil

     

       209
       209
       +
       		}

     

       210
       210
       +
       		return fmt.Errorf("failed to create user: %w", err)

     

       211
       211
       +
       	}

     

       212
       212
       +
       

     

       213
       213
       +
       	log.Printf("Indexed new user: %s (%s)", handle, did)

     

       214
       214
       +
       	return nil

     

       215
       215
       +
       }

     

       216
       216
       +
       

     

       217
       217
       +
       // handleAccountEvent processes account events (account creation/updates)

     

       218
       218
       +
       func (c *UserEventConsumer) handleAccountEvent(ctx context.Context, event *JetstreamEvent) error {

     

       219
       219
       +
       	if event.Account == nil {

     

       220
       220
       +
       		return fmt.Errorf("account event missing account data")

     

       221
       221
       +
       	}

     

       222
       222
       +
       

     

       223
       223
       +
       	did := event.Account.Did

     

       224
       224
       +
       	if did == "" {

     

       225
       225
       +
       		return fmt.Errorf("account event missing did")

     

       226
       226
       +
       	}

     

       227
       227
       +
       

     

       228
       228
       +
       	// Account events don't include handle, so we can't index yet

     

       229
       229
       +
       	// We'll wait for the corresponding identity event

     

       230
       230
       +
       	log.Printf("Account event for %s (waiting for identity event)", did)

     

       231
       231
       +
       	return nil

     

       232
       232
       +
       }

     

       233
       233
       +
       

     

       234
       234
       +
       // isDuplicateError checks if error is due to duplicate DID/handle

     

       235
       235
       +
       func isDuplicateError(err error) bool {

     

       236
       236
       +
       	if err == nil {

     

       237
       237
       +
       		return false

     

       238
       238
       +
       	}

     

       239
       239
       +
       	errStr := err.Error()

     

       240
       240
       +
       	return contains(errStr, "already exists") || contains(errStr, "already taken") || contains(errStr, "duplicate")

     

       241
       241
       +
       }

     

       242
       242
       +
       

     

       243
       243
       +
       func contains(s, substr string) bool {

     

       244
       244
       +
       	return len(s) >= len(substr) && (s == substr || len(s) > len(substr) && anySubstring(s, substr))

     

       245
       245
       +
       }

     

       246
       246
       +
       

     

       247
       247
       +
       func anySubstring(s, substr string) bool {

     

       248
       248
       +
       	for i := 0; i <= len(s)-len(substr); i++ {

     

       249
       249
       +
       		if s[i:i+len(substr)] == substr {

     

       250
       250
       +
       			return true

     

       251
       251
       +
       		}

     

       252
       252
       +
       	}

     

       253
       253
       +
       	return false

     

       254
       254
       +
       }

+410

tests/e2e/user_signup_test.go

···

       1
       1
       +
       package e2e

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"bytes"

     

       5
       5
       +
       	"context"

     

       6
       6
       +
       	"database/sql"

     

       7
       7
       +
       	"encoding/json"

     

       8
       8
       +
       	"fmt"

     

       9
       9
       +
       	"net/http"

     

       10
       10
       +
       	"os"

     

       11
       11
       +
       	"testing"

     

       12
       12
       +
       	"time"

     

       13
       13
       +
       

     

       14
       14
       +
       	"Coves/internal/core/users"

     

       15
       15
       +
       	"Coves/internal/db/postgres"

     

       16
       16
       +
       	"Coves/internal/jetstream"

     

       17
       17
       +
       	_ "github.com/lib/pq"

     

       18
       18
       +
       	"github.com/pressly/goose/v3"

     

       19
       19
       +
       )

     

       20
       20
       +
       

     

       21
       21
       +
       // TestE2E_UserSignup tests the full user signup flow:

     

       22
       22
       +
       // Third-party client → social.coves.actor.signup XRPC → PDS account creation → Jetstream → AppView indexing

     

       23
       23
       +
       //

     

       24
       24
       +
       // This tests the same code path that a third-party client or UI would use.

     

       25
       25
       +
       //

     

       26
       26
       +
       // Prerequisites:

     

       27
       27
       +
       //   - AppView running on localhost:8081

     

       28
       28
       +
       //   - PDS running on localhost:3001

     

       29
       29
       +
       //   - Jetstream running on localhost:6008 (consuming from PDS)

     

       30
       30
       +
       //   - Test database on localhost:5434

     

       31
       31
       +
       //

     

       32
       32
       +
       // Run with:

     

       33
       33
       +
       //   make e2e-up  # Start infrastructure

     

       34
       34
       +
       //   go run ./cmd/server &  # Start AppView

     

       35
       35
       +
       //   go test ./tests/integration -run TestE2E_UserSignup -v

     

       36
       36
       +
       func TestE2E_UserSignup(t *testing.T) {

     

       37
       37
       +
       	if testing.Short() {

     

       38
       38
       +
       		t.Skip("Skipping E2E test in short mode")

     

       39
       39
       +
       	}

     

       40
       40
       +
       

     

       41
       41
       +
       	// Check if AppView is available

     

       42
       42
       +
       	if !isAppViewAvailable(t) {

     

       43
       43
       +
       		t.Skip("AppView not available at localhost:8081 - run 'go run ./cmd/server' first")

     

       44
       44
       +
       	}

     

       45
       45
       +
       

     

       46
       46
       +
       	// Check if PDS is available

     

       47
       47
       +
       	if !isPDSAvailable(t) {

     

       48
       48
       +
       		t.Skip("PDS not available at localhost:3001 - run 'make e2e-up' first")

     

       49
       49
       +
       	}

     

       50
       50
       +
       

     

       51
       51
       +
       	// Check if Jetstream is available

     

       52
       52
       +
       	if !isJetstreamAvailable(t) {

     

       53
       53
       +
       		t.Skip("Jetstream not available at localhost:6008 - run 'make e2e-up' first")

     

       54
       54
       +
       	}

     

       55
       55
       +
       

     

       56
       56
       +
       	db := setupTestDB(t)

     

       57
       57
       +
       	defer db.Close()

     

       58
       58
       +
       

     

       59
       59
       +
       	// Set up services

     

       60
       60
       +
       	userRepo := postgres.NewUserRepository(db)

     

       61
       61
       +
       	userService := users.NewUserService(userRepo, "http://localhost:3001")

     

       62
       62
       +
       

     

       63
       63
       +
       	// Start Jetstream consumer

     

       64
       64
       +
       	consumer := jetstream.NewUserEventConsumer(

     

       65
       65
       +
       		userService,

     

       66
       66
       +
       		"ws://localhost:6008/subscribe",

     

       67
       67
       +
       		"", // No PDS filter

     

       68
       68
       +
       	)

     

       69
       69
       +
       

     

       70
       70
       +
       	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)

     

       71
       71
       +
       	defer cancel()

     

       72
       72
       +
       

     

       73
       73
       +
       	// Start consumer in background

     

       74
       74
       +
       	consumerDone := make(chan error, 1)

     

       75
       75
       +
       	go func() {

     

       76
       76
       +
       		consumerDone <- consumer.Start(ctx)

     

       77
       77
       +
       	}()

     

       78
       78
       +
       

     

       79
       79
       +
       	// Give Jetstream consumer a moment to connect (no need to wait long)

     

       80
       80
       +
       	t.Log("Waiting for Jetstream consumer to connect...")

     

       81
       81
       +
       	time.Sleep(500 * time.Millisecond)

     

       82
       82
       +
       

     

       83
       83
       +
       	// Test 1: Create account on PDS

     

       84
       84
       +
       	t.Run("Create account on PDS and verify indexing", func(t *testing.T) {

     

       85
       85
       +
       		handle := fmt.Sprintf("alice-%d.local.coves.dev", time.Now().Unix())

     

       86
       86
       +
       		email := fmt.Sprintf("alice-%d@test.com", time.Now().Unix())

     

       87
       87
       +
       

     

       88
       88
       +
       		t.Logf("Creating account: %s", handle)

     

       89
       89
       +
       

     

       90
       90
       +
       		// Create account via UserService (what UI would call)

     

       91
       91
       +
       		did, err := createPDSAccount(t, userService, handle, email, "test1234")

     

       92
       92
       +
       		if err != nil {

     

       93
       93
       +
       			t.Fatalf("Failed to create PDS account: %v", err)

     

       94
       94
       +
       		}

     

       95
       95
       +
       

     

       96
       96
       +
       		t.Logf("Account created with DID: %s", did)

     

       97
       97
       +
       

     

       98
       98
       +
       		// Wait for Jetstream to process and AppView to index (with retry)

     

       99
       99
       +
       		t.Log("Waiting for Jetstream → AppView indexing...")

     

       100
       100
       +
       		var user *users.User

     

       101
       101
       +
       		deadline := time.Now().Add(10 * time.Second)

     

       102
       102
       +
       		for time.Now().Before(deadline) {

     

       103
       103
       +
       			user, err = userService.GetUserByDID(ctx, did)

     

       104
       104
       +
       			if err == nil {

     

       105
       105
       +
       				break // Successfully indexed!

     

       106
       106
       +
       			}

     

       107
       107
       +
       			time.Sleep(500 * time.Millisecond)

     

       108
       108
       +
       		}

     

       109
       109
       +
       		if err != nil {

     

       110
       110
       +
       			t.Fatalf("User not indexed in AppView after 10s: %v", err)

     

       111
       111
       +
       		}

     

       112
       112
       +
       

     

       113
       113
       +
       		if user.Handle != handle {

     

       114
       114
       +
       			t.Errorf("Expected handle %s, got %s", handle, user.Handle)

     

       115
       115
       +
       		}

     

       116
       116
       +
       

     

       117
       117
       +
       		if user.DID != did {

     

       118
       118
       +
       			t.Errorf("Expected DID %s, got %s", did, user.DID)

     

       119
       119
       +
       		}

     

       120
       120
       +
       

     

       121
       121
       +
       		t.Logf("✅ User successfully indexed: %s → %s", handle, did)

     

       122
       122
       +
       	})

     

       123
       123
       +
       

     

       124
       124
       +
       	// Test 2: Idempotency

     

       125
       125
       +
       	t.Run("Idempotent indexing on duplicate events", func(t *testing.T) {

     

       126
       126
       +
       		handle := fmt.Sprintf("bob-%d.local.coves.dev", time.Now().Unix())

     

       127
       127
       +
       		email := fmt.Sprintf("bob-%d@test.com", time.Now().Unix())

     

       128
       128
       +
       

     

       129
       129
       +
       		// Create account via UserService

     

       130
       130
       +
       		did, err := createPDSAccount(t, userService, handle, email, "test1234")

     

       131
       131
       +
       		if err != nil {

     

       132
       132
       +
       			t.Fatalf("Failed to create PDS account: %v", err)

     

       133
       133
       +
       		}

     

       134
       134
       +
       

     

       135
       135
       +
       		// Wait for indexing (with retry)

     

       136
       136
       +
       		var user1 *users.User

     

       137
       137
       +
       		deadline := time.Now().Add(10 * time.Second)

     

       138
       138
       +
       		for time.Now().Before(deadline) {

     

       139
       139
       +
       			user1, err = userService.GetUserByDID(ctx, did)

     

       140
       140
       +
       			if err == nil {

     

       141
       141
       +
       				break

     

       142
       142
       +
       			}

     

       143
       143
       +
       			time.Sleep(500 * time.Millisecond)

     

       144
       144
       +
       		}

     

       145
       145
       +
       		if err != nil {

     

       146
       146
       +
       			t.Fatalf("User not indexed after 10s: %v", err)

     

       147
       147
       +
       		}

     

       148
       148
       +
       

     

       149
       149
       +
       		// Manually trigger duplicate indexing (simulates Jetstream replay)

     

       150
       150
       +
       		_, err = userService.CreateUser(ctx, users.CreateUserRequest{

     

       151
       151
       +
       			DID:    did,

     

       152
       152
       +
       			Handle: handle,

     

       153
       153
       +
       			PDSURL: "http://localhost:3001",

     

       154
       154
       +
       		})

     

       155
       155
       +
       		if err != nil {

     

       156
       156
       +
       			t.Fatalf("Idempotent CreateUser should not error: %v", err)

     

       157
       157
       +
       		}

     

       158
       158
       +
       

     

       159
       159
       +
       		// Verify still only one user

     

       160
       160
       +
       		user2, err := userService.GetUserByDID(ctx, did)

     

       161
       161
       +
       		if err != nil {

     

       162
       162
       +
       			t.Fatalf("Failed to get user after duplicate: %v", err)

     

       163
       163
       +
       		}

     

       164
       164
       +
       

     

       165
       165
       +
       		if user1.CreatedAt != user2.CreatedAt {

     

       166
       166
       +
       			t.Errorf("Duplicate indexing created new user (timestamps differ)")

     

       167
       167
       +
       		}

     

       168
       168
       +
       

     

       169
       169
       +
       		t.Logf("✅ Idempotency verified: duplicate events handled gracefully")

     

       170
       170
       +
       	})

     

       171
       171
       +
       

     

       172
       172
       +
       	// Test 3: Multiple users

     

       173
       173
       +
       	t.Run("Index multiple users concurrently", func(t *testing.T) {

     

       174
       174
       +
       		const numUsers = 3

     

       175
       175
       +
       		dids := make([]string, numUsers)

     

       176
       176
       +
       

     

       177
       177
       +
       		for i := 0; i < numUsers; i++ {

     

       178
       178
       +
       			handle := fmt.Sprintf("user%d-%d.local.coves.dev", i, time.Now().Unix())

     

       179
       179
       +
       			email := fmt.Sprintf("user%d-%d@test.com", i, time.Now().Unix())

     

       180
       180
       +
       

     

       181
       181
       +
       			did, err := createPDSAccount(t, userService, handle, email, "test1234")

     

       182
       182
       +
       			if err != nil {

     

       183
       183
       +
       				t.Fatalf("Failed to create account %d: %v", i, err)

     

       184
       184
       +
       			}

     

       185
       185
       +
       			dids[i] = did

     

       186
       186
       +
       			t.Logf("Created user %d: %s", i, did)

     

       187
       187
       +
       

     

       188
       188
       +
       			// Small delay between creations

     

       189
       189
       +
       			time.Sleep(500 * time.Millisecond)

     

       190
       190
       +
       		}

     

       191
       191
       +
       

     

       192
       192
       +
       		// Verify all indexed (with retry for each user)

     

       193
       193
       +
       		t.Log("Waiting for all users to be indexed...")

     

       194
       194
       +
       		for i, did := range dids {

     

       195
       195
       +
       			var user *users.User

     

       196
       196
       +
       			var err error

     

       197
       197
       +
       			deadline := time.Now().Add(15 * time.Second)

     

       198
       198
       +
       			for time.Now().Before(deadline) {

     

       199
       199
       +
       				user, err = userService.GetUserByDID(ctx, did)

     

       200
       200
       +
       				if err == nil {

     

       201
       201
       +
       					break

     

       202
       202
       +
       				}

     

       203
       203
       +
       				time.Sleep(500 * time.Millisecond)

     

       204
       204
       +
       			}

     

       205
       205
       +
       			if err != nil {

     

       206
       206
       +
       				t.Errorf("User %d not indexed after 15s: %v", i, err)

     

       207
       207
       +
       				continue

     

       208
       208
       +
       			}

     

       209
       209
       +
       			t.Logf("✅ User %d indexed: %s", i, user.Handle)

     

       210
       210
       +
       		}

     

       211
       211
       +
       	})

     

       212
       212
       +
       

     

       213
       213
       +
       	// Clean shutdown

     

       214
       214
       +
       	cancel()

     

       215
       215
       +
       	select {

     

       216
       216
       +
       	case err := <-consumerDone:

     

       217
       217
       +
       		if err != nil && err != context.Canceled {

     

       218
       218
       +
       			t.Logf("Consumer stopped with error: %v", err)

     

       219
       219
       +
       		}

     

       220
       220
       +
       	case <-time.After(5 * time.Second):

     

       221
       221
       +
       		t.Log("Consumer shutdown timeout")

     

       222
       222
       +
       	}

     

       223
       223
       +
       }

     

       224
       224
       +
       

     

       225
       225
       +
       // generateInviteCode generates a single-use invite code via PDS admin API

     

       226
       226
       +
       func generateInviteCode(t *testing.T) (string, error) {

     

       227
       227
       +
       	payload := map[string]int{

     

       228
       228
       +
       		"useCount": 1,

     

       229
       229
       +
       	}

     

       230
       230
       +
       

     

       231
       231
       +
       	jsonData, err := json.Marshal(payload)

     

       232
       232
       +
       	if err != nil {

     

       233
       233
       +
       		return "", fmt.Errorf("failed to marshal request: %w", err)

     

       234
       234
       +
       	}

     

       235
       235
       +
       

     

       236
       236
       +
       	req, err := http.NewRequest(

     

       237
       237
       +
       		"POST",

     

       238
       238
       +
       		"http://localhost:3001/xrpc/com.atproto.server.createInviteCode",

     

       239
       239
       +
       		bytes.NewBuffer(jsonData),

     

       240
       240
       +
       	)

     

       241
       241
       +
       	if err != nil {

     

       242
       242
       +
       		return "", fmt.Errorf("failed to create request: %w", err)

     

       243
       243
       +
       	}

     

       244
       244
       +
       

     

       245
       245
       +
       	// PDS admin authentication

     

       246
       246
       +
       	req.SetBasicAuth("admin", "admin")

     

       247
       247
       +
       	req.Header.Set("Content-Type", "application/json")

     

       248
       248
       +
       

     

       249
       249
       +
       	resp, err := http.DefaultClient.Do(req)

     

       250
       250
       +
       	if err != nil {

     

       251
       251
       +
       		return "", fmt.Errorf("failed to create invite code: %w", err)

     

       252
       252
       +
       	}

     

       253
       253
       +
       	defer resp.Body.Close()

     

       254
       254
       +
       

     

       255
       255
       +
       	if resp.StatusCode != http.StatusOK {

     

       256
       256
       +
       		var errorResp map[string]interface{}

     

       257
       257
       +
       		json.NewDecoder(resp.Body).Decode(&errorResp)

     

       258
       258
       +
       		return "", fmt.Errorf("PDS admin API returned status %d: %v", resp.StatusCode, errorResp)

     

       259
       259
       +
       	}

     

       260
       260
       +
       

     

       261
       261
       +
       	var result struct {

     

       262
       262
       +
       		Code string `json:"code"`

     

       263
       263
       +
       	}

     

       264
       264
       +
       

     

       265
       265
       +
       	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {

     

       266
       266
       +
       		return "", fmt.Errorf("failed to decode response: %w", err)

     

       267
       267
       +
       	}

     

       268
       268
       +
       

     

       269
       269
       +
       	t.Logf("Generated invite code: %s", result.Code)

     

       270
       270
       +
       	return result.Code, nil

     

       271
       271
       +
       }

     

       272
       272
       +
       

     

       273
       273
       +
       // createPDSAccount creates an account via the coves.user.signup XRPC endpoint

     

       274
       274
       +
       // This is the same code path that a third-party client or UI would use

     

       275
       275
       +
       func createPDSAccount(t *testing.T, userService users.UserService, handle, email, password string) (string, error) {

     

       276
       276
       +
       	// Generate fresh invite code for each account

     

       277
       277
       +
       	inviteCode, err := generateInviteCode(t)

     

       278
       278
       +
       	if err != nil {

     

       279
       279
       +
       		return "", fmt.Errorf("failed to generate invite code: %w", err)

     

       280
       280
       +
       	}

     

       281
       281
       +
       

     

       282
       282
       +
       	// Call our XRPC endpoint (what a third-party client would call)

     

       283
       283
       +
       	payload := map[string]string{

     

       284
       284
       +
       		"handle":     handle,

     

       285
       285
       +
       		"email":      email,

     

       286
       286
       +
       		"password":   password,

     

       287
       287
       +
       		"inviteCode": inviteCode,

     

       288
       288
       +
       	}

     

       289
       289
       +
       

     

       290
       290
       +
       	jsonData, err := json.Marshal(payload)

     

       291
       291
       +
       	if err != nil {

     

       292
       292
       +
       		return "", fmt.Errorf("failed to marshal request: %w", err)

     

       293
       293
       +
       	}

     

       294
       294
       +
       

     

       295
       295
       +
       	resp, err := http.Post(

     

       296
       296
       +
       		"http://localhost:8081/xrpc/social.coves.actor.signup",

     

       297
       297
       +
       		"application/json",

     

       298
       298
       +
       		bytes.NewBuffer(jsonData),

     

       299
       299
       +
       	)

     

       300
       300
       +
       	if err != nil {

     

       301
       301
       +
       		return "", fmt.Errorf("failed to call signup endpoint: %w", err)

     

       302
       302
       +
       	}

     

       303
       303
       +
       	defer resp.Body.Close()

     

       304
       304
       +
       

     

       305
       305
       +
       	if resp.StatusCode != http.StatusOK {

     

       306
       306
       +
       		var errorResp map[string]interface{}

     

       307
       307
       +
       		json.NewDecoder(resp.Body).Decode(&errorResp)

     

       308
       308
       +
       		return "", fmt.Errorf("signup endpoint returned status %d: %v", resp.StatusCode, errorResp)

     

       309
       309
       +
       	}

     

       310
       310
       +
       

     

       311
       311
       +
       	var result struct {

     

       312
       312
       +
       		DID         string `json:"did"`

     

       313
       313
       +
       		Handle      string `json:"handle"`

     

       314
       314
       +
       		AccessJwt   string `json:"accessJwt"`

     

       315
       315
       +
       		RefreshJwt  string `json:"refreshJwt"`

     

       316
       316
       +
       	}

     

       317
       317
       +
       

     

       318
       318
       +
       	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {

     

       319
       319
       +
       		return "", fmt.Errorf("failed to decode response: %w", err)

     

       320
       320
       +
       	}

     

       321
       321
       +
       

     

       322
       322
       +
       	t.Logf("Account created via XRPC endpoint: %s → %s", result.Handle, result.DID)

     

       323
       323
       +
       

     

       324
       324
       +
       	return result.DID, nil

     

       325
       325
       +
       }

     

       326
       326
       +
       

     

       327
       327
       +
       // isPDSAvailable checks if PDS is running

     

       328
       328
       +
       func isPDSAvailable(t *testing.T) bool {

     

       329
       329
       +
       	resp, err := http.Get("http://localhost:3001/xrpc/_health")

     

       330
       330
       +
       	if err != nil {

     

       331
       331
       +
       		t.Logf("PDS not available: %v", err)

     

       332
       332
       +
       		return false

     

       333
       333
       +
       	}

     

       334
       334
       +
       	defer resp.Body.Close()

     

       335
       335
       +
       	return resp.StatusCode == http.StatusOK

     

       336
       336
       +
       }

     

       337
       337
       +
       

     

       338
       338
       +
       // isJetstreamAvailable checks if Jetstream is running

     

       339
       339
       +
       func isJetstreamAvailable(t *testing.T) bool {

     

       340
       340
       +
       	// Use 127.0.0.1 instead of localhost to force IPv4

     

       341
       341
       +
       	resp, err := http.Get("http://127.0.0.1:6009/metrics")

     

       342
       342
       +
       	if err != nil {

     

       343
       343
       +
       		t.Logf("Jetstream not available: %v", err)

     

       344
       344
       +
       		return false

     

       345
       345
       +
       	}

     

       346
       346
       +
       	defer resp.Body.Close()

     

       347
       347
       +
       	return resp.StatusCode == http.StatusOK

     

       348
       348
       +
       }

     

       349
       349
       +
       

     

       350
       350
       +
       // isAppViewAvailable checks if AppView is running

     

       351
       351
       +
       func isAppViewAvailable(t *testing.T) bool {

     

       352
       352
       +
       	resp, err := http.Get("http://localhost:8081/health")

     

       353
       353
       +
       	if err != nil {

     

       354
       354
       +
       		t.Logf("AppView not available: %v", err)

     

       355
       355
       +
       		return false

     

       356
       356
       +
       	}

     

       357
       357
       +
       	defer resp.Body.Close()

     

       358
       358
       +
       	return resp.StatusCode == http.StatusOK

     

       359
       359
       +
       }

     

       360
       360
       +
       

     

       361
       361
       +
       // setupTestDB connects to test database and runs migrations

     

       362
       362
       +
       func setupTestDB(t *testing.T) *sql.DB {

     

       363
       363
       +
       	// Build connection string from environment variables (set by .env.dev)

     

       364
       364
       +
       	testUser := os.Getenv("POSTGRES_TEST_USER")

     

       365
       365
       +
       	testPassword := os.Getenv("POSTGRES_TEST_PASSWORD")

     

       366
       366
       +
       	testPort := os.Getenv("POSTGRES_TEST_PORT")

     

       367
       367
       +
       	testDB := os.Getenv("POSTGRES_TEST_DB")

     

       368
       368
       +
       

     

       369
       369
       +
       	// Fallback to defaults if not set

     

       370
       370
       +
       	if testUser == "" {

     

       371
       371
       +
       		testUser = "test_user"

     

       372
       372
       +
       	}

     

       373
       373
       +
       	if testPassword == "" {

     

       374
       374
       +
       		testPassword = "test_password"

     

       375
       375
       +
       	}

     

       376
       376
       +
       	if testPort == "" {

     

       377
       377
       +
       		testPort = "5434"

     

       378
       378
       +
       	}

     

       379
       379
       +
       	if testDB == "" {

     

       380
       380
       +
       		testDB = "coves_test"

     

       381
       381
       +
       	}

     

       382
       382
       +
       

     

       383
       383
       +
       	dbURL := fmt.Sprintf("postgres://%s:%s@localhost:%s/%s?sslmode=disable",

     

       384
       384
       +
       		testUser, testPassword, testPort, testDB)

     

       385
       385
       +
       

     

       386
       386
       +
       	db, err := sql.Open("postgres", dbURL)

     

       387
       387
       +
       	if err != nil {

     

       388
       388
       +
       		t.Fatalf("Failed to connect to test database: %v", err)

     

       389
       389
       +
       	}

     

       390
       390
       +
       

     

       391
       391
       +
       	if err := db.Ping(); err != nil {

     

       392
       392
       +
       		t.Fatalf("Failed to ping test database: %v", err)

     

       393
       393
       +
       	}

     

       394
       394
       +
       

     

       395
       395
       +
       	if err := goose.SetDialect("postgres"); err != nil {

     

       396
       396
       +
       		t.Fatalf("Failed to set goose dialect: %v", err)

     

       397
       397
       +
       	}

     

       398
       398
       +
       

     

       399
       399
       +
       	if err := goose.Up(db, "../../internal/db/migrations"); err != nil {

     

       400
       400
       +
       		t.Fatalf("Failed to run migrations: %v", err)

     

       401
       401
       +
       	}

     

       402
       402
       +
       

     

       403
       403
       +
       	// Clean up any existing test data

     

       404
       404
       +
       	_, err = db.Exec("DELETE FROM users WHERE handle LIKE '%.test' OR handle LIKE '%.local.coves.dev'")

     

       405
       405
       +
       	if err != nil {

     

       406
       406
       +
       		t.Logf("Warning: Failed to clean up test data: %v", err)

     

       407
       407
       +
       	}

     

       408
       408
       +
       

     

       409
       409
       +
       	return db

     

       410
       410
       +
       }

+47 -22

tests/integration/integration_test.go tests/integration/user_test.go

···

       85
       85
        
       		req := users.CreateUserRequest{

     

       86
       86
        
       			DID:    "did:plc:test123456",

     

       87
       87
        
       			Handle: "alice.test",

     

       88
       88
       +
       			PDSURL: "http://localhost:3001",

     

       88
       89
        
       		}

     

       89
       90
        
       

     

       90
       91
        
       		user, err := userService.CreateUser(ctx, req)

     
···

       155
       156
        
       	_, err := userService.CreateUser(ctx, users.CreateUserRequest{

     

       156
       157
        
       		DID:    "did:plc:endpoint123",

     

       157
       158
        
       		Handle: "bob.test",

     

       159
       159
       +
       		PDSURL: "http://localhost:3001",

     

       158
       160
        
       	})

     

       159
       161
        
       	if err != nil {

     

       160
       162
        
       		t.Fatalf("Failed to create test user: %v", err)

     
···

       162
       164
        
       

     

       163
       165
        
       	// Set up HTTP router

     

       164
       166
        
       	r := chi.NewRouter()

     

       165
       165
       -
       	r.Mount("/xrpc/social.coves.actor", routes.UserRoutes(userService))

     

       167
       167
       +
       	routes.RegisterUserRoutes(r, userService)

     

       166
       168
        
       

     

       167
       169
        
       	// Test 1: Get profile by DID

     

       168
       170
        
       	t.Run("Get Profile By DID", func(t *testing.T) {

     

       169
       169
       -
       		req := httptest.NewRequest("GET", "/xrpc/social.coves.actor/profile?actor=did:plc:endpoint123", nil)

     

       171
       171
       +
       		req := httptest.NewRequest("GET", "/xrpc/social.coves.actor.getProfile?actor=did:plc:endpoint123", nil)

     

       170
       172
        
       		w := httptest.NewRecorder()

     

       171
       173
        
       		r.ServeHTTP(w, req)

     

       172
       174
        
       

     
···

       187
       189
        
       

     

       188
       190
        
       	// Test 2: Get profile by handle

     

       189
       191
        
       	t.Run("Get Profile By Handle", func(t *testing.T) {

     

       190
       190
       -
       		req := httptest.NewRequest("GET", "/xrpc/social.coves.actor/profile?actor=bob.test", nil)

     

       192
       192
       +
       		req := httptest.NewRequest("GET", "/xrpc/social.coves.actor.getProfile?actor=bob.test", nil)

     

       191
       193
        
       		w := httptest.NewRecorder()

     

       192
       194
        
       		r.ServeHTTP(w, req)

     

       193
       195
        
       

     
···

       209
       211
        
       

     

       210
       212
        
       	// Test 3: Missing actor parameter

     

       211
       213
        
       	t.Run("Missing Actor Parameter", func(t *testing.T) {

     

       212
       212
       -
       		req := httptest.NewRequest("GET", "/xrpc/social.coves.actor/profile", nil)

     

       214
       214
       +
       		req := httptest.NewRequest("GET", "/xrpc/social.coves.actor.getProfile", nil)

     

       213
       215
        
       		w := httptest.NewRecorder()

     

       214
       216
        
       		r.ServeHTTP(w, req)

     

       215
       217
        
       

     
···

       220
       222
        
       

     

       221
       223
        
       	// Test 4: User not found

     

       222
       224
        
       	t.Run("User Not Found", func(t *testing.T) {

     

       223
       223
       -
       		req := httptest.NewRequest("GET", "/xrpc/social.coves.actor/profile?actor=nonexistent.test", nil)

     

       225
       225
       +
       		req := httptest.NewRequest("GET", "/xrpc/social.coves.actor.getProfile?actor=nonexistent.test", nil)

     

       224
       226
        
       		w := httptest.NewRecorder()

     

       225
       227
        
       		r.ServeHTTP(w, req)

     

       226
       228
        
       

     
···

       243
       245
        
       	_, err := userService.CreateUser(ctx, users.CreateUserRequest{

     

       244
       246
        
       		DID:    "did:plc:duplicate123",

     

       245
       247
        
       		Handle: "duplicate.test",

     

       248
       248
       +
       		PDSURL: "http://localhost:3001",

     

       246
       249
        
       	})

     

       247
       250
        
       	if err != nil {

     

       248
       251
        
       		t.Fatalf("Failed to create first user: %v", err)

     

       249
       252
        
       	}

     

       250
       253
        
       

     

       251
       251
       -
       	// Test duplicate DID

     

       252
       252
       -
       	t.Run("Duplicate DID", func(t *testing.T) {

     

       253
       253
       -
       		_, err := userService.CreateUser(ctx, users.CreateUserRequest{

     

       254
       254
       +
       	// Test duplicate DID - now idempotent, returns existing user

     

       255
       255
       +
       	t.Run("Duplicate DID - Idempotent", func(t *testing.T) {

     

       256
       256
       +
       		user, err := userService.CreateUser(ctx, users.CreateUserRequest{

     

       254
       257
        
       			DID:    "did:plc:duplicate123",

     

       255
       255
       -
       			Handle: "different.test",

     

       258
       258
       +
       			Handle: "different.test", // Different handle, same DID

     

       259
       259
       +
       			PDSURL: "http://localhost:3001",

     

       256
       260
        
       		})

     

       257
       261
        
       

     

       258
       258
       -
       		if err == nil {

     

       259
       259
       -
       			t.Error("Expected error for duplicate DID, got nil")

     

       262
       262
       +
       		// Should return existing user, not error

     

       263
       263
       +
       		if err != nil {

     

       264
       264
       +
       			t.Fatalf("Expected idempotent behavior, got error: %v", err)

     

       260
       265
        
       		}

     

       261
       266
        
       

     

       262
       262
       -
       		if !strings.Contains(err.Error(), "DID already exists") {

     

       263
       263
       -
       			t.Errorf("Expected 'DID already exists' error, got: %v", err)

     

       267
       267
       +
       		// Should return the original user (with original handle)

     

       268
       268
       +
       		if user.Handle != "duplicate.test" {

     

       269
       269
       +
       			t.Errorf("Expected original handle 'duplicate.test', got: %s", user.Handle)

     

       264
       270
        
       		}

     

       265
       271
        
       	})

     

       266
       272
        
       

     
···

       269
       275
        
       		_, err := userService.CreateUser(ctx, users.CreateUserRequest{

     

       270
       276
        
       			DID:    "did:plc:different456",

     

       271
       277
        
       			Handle: "duplicate.test",

     

       278
       278
       +
       			PDSURL: "http://localhost:3001",

     

       272
       279
        
       		})

     

       273
       280
        
       

     

       274
       281
        
       		if err == nil {

     
···

       294
       301
        
       		name        string

     

       295
       302
        
       		did         string

     

       296
       303
        
       		handle      string

     

       304
       304
       +
       		pdsURL      string

     

       297
       305
        
       		shouldError bool

     

       298
       306
        
       		errorMsg    string

     

       299
       307
        
       	}{

     
···

       301
       309
        
       			name:        "Valid handle with hyphen",

     

       302
       310
        
       			did:         "did:plc:valid1",

     

       303
       311
        
       			handle:      "alice-bob.test",

     

       312
       312
       +
       			pdsURL:      "http://localhost:3001",

     

       304
       313
        
       			shouldError: false,

     

       305
       314
        
       		},

     

       306
       315
        
       		{

     

       307
       316
        
       			name:        "Valid handle with dots",

     

       308
       317
        
       			did:         "did:plc:valid2",

     

       309
       318
        
       			handle:      "alice.bob.test",

     

       319
       319
       +
       			pdsURL:      "http://localhost:3001",

     

       310
       320
        
       			shouldError: false,

     

       311
       321
        
       		},

     

       312
       322
        
       		{

     

       313
       313
       -
       			name:        "Invalid: consecutive hyphens",

     

       314
       314
       -
       			did:         "did:plc:invalid1",

     

       323
       323
       +
       			name:        "Invalid: no dot (not domain-like)",

     

       324
       324
       +
       			did:         "did:plc:invalid8",

     

       325
       325
       +
       			handle:      "alice",

     

       326
       326
       +
       			pdsURL:      "http://localhost:3001",

     

       327
       327
       +
       			shouldError: true,

     

       328
       328
       +
       			errorMsg:    "invalid handle",

     

       329
       329
       +
       		},

     

       330
       330
       +
       		{

     

       331
       331
       +
       			name:        "Valid: consecutive hyphens (allowed per atProto spec)",

     

       332
       332
       +
       			did:         "did:plc:valid3",

     

       315
       333
        
       			handle:      "alice--bob.test",

     

       316
       316
       -
       			shouldError: true,

     

       317
       317
       -
       			errorMsg:    "consecutive hyphens",

     

       334
       334
       +
       			pdsURL:      "http://localhost:3001",

     

       335
       335
       +
       			shouldError: false,

     

       318
       336
        
       		},

     

       319
       337
        
       		{

     

       320
       338
        
       			name:        "Invalid: starts with hyphen",

     

       321
       339
        
       			did:         "did:plc:invalid2",

     

       322
       340
        
       			handle:      "-alice.test",

     

       341
       341
       +
       			pdsURL:      "http://localhost:3001",

     

       323
       342
        
       			shouldError: true,

     

       324
       324
       -
       			errorMsg:    "invalid handle format",

     

       343
       343
       +
       			errorMsg:    "invalid handle",

     

       325
       344
        
       		},

     

       326
       345
        
       		{

     

       327
       346
        
       			name:        "Invalid: ends with hyphen",

     

       328
       347
        
       			did:         "did:plc:invalid3",

     

       329
       348
        
       			handle:      "alice-.test",

     

       349
       349
       +
       			pdsURL:      "http://localhost:3001",

     

       330
       350
        
       			shouldError: true,

     

       331
       331
       -
       			errorMsg:    "invalid handle format",

     

       351
       351
       +
       			errorMsg:    "invalid handle",

     

       332
       352
        
       		},

     

       333
       353
        
       		{

     

       334
       354
        
       			name:        "Invalid: special characters",

     

       335
       355
        
       			did:         "did:plc:invalid4",

     

       336
       356
        
       			handle:      "alice!bob.test",

     

       357
       357
       +
       			pdsURL:      "http://localhost:3001",

     

       337
       358
        
       			shouldError: true,

     

       338
       338
       -
       			errorMsg:    "invalid handle format",

     

       359
       359
       +
       			errorMsg:    "invalid handle",

     

       339
       360
        
       		},

     

       340
       361
        
       		{

     

       341
       362
        
       			name:        "Invalid: spaces",

     

       342
       363
        
       			did:         "did:plc:invalid5",

     

       343
       364
        
       			handle:      "alice bob.test",

     

       365
       365
       +
       			pdsURL:      "http://localhost:3001",

     

       344
       366
        
       			shouldError: true,

     

       345
       345
       -
       			errorMsg:    "invalid handle format",

     

       367
       367
       +
       			errorMsg:    "invalid handle",

     

       346
       368
        
       		},

     

       347
       369
        
       		{

     

       348
       370
        
       			name:        "Invalid: too long",

     

       349
       371
        
       			did:         "did:plc:invalid6",

     

       350
       372
        
       			handle:      strings.Repeat("a", 254) + ".test",

     

       373
       373
       +
       			pdsURL:      "http://localhost:3001",

     

       351
       374
        
       			shouldError: true,

     

       352
       352
       -
       			errorMsg:    "must be between 1 and 253 characters",

     

       375
       375
       +
       			errorMsg:    "invalid handle",

     

       353
       376
        
       		},

     

       354
       377
        
       		{

     

       355
       378
        
       			name:        "Invalid: missing DID prefix",

     

       356
       379
        
       			did:         "plc:invalid7",

     

       357
       380
        
       			handle:      "valid.test",

     

       381
       381
       +
       			pdsURL:      "http://localhost:3001",

     

       358
       382
        
       			shouldError: true,

     

       359
       383
        
       			errorMsg:    "must start with 'did:'",

     

       360
       384
        
       		},

     
···

       365
       389
        
       			_, err := userService.CreateUser(ctx, users.CreateUserRequest{

     

       366
       390
        
       				DID:    tc.did,

     

       367
       391
        
       				Handle: tc.handle,

     

       392
       392
       +
       				PDSURL: tc.pdsURL,

     

       368
       393
        
       			})

     

       369
       394
        
       

     

       370
       395
        
       			if tc.shouldError {

+271

tests/integration/jetstream_consumer_test.go

···

       1
       1
       +
       package integration

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"context"

     

       5
       5
       +
       	"testing"

     

       6
       6
       +
       	"time"

     

       7
       7
       +
       

     

       8
       8
       +
       	"Coves/internal/core/users"

     

       9
       9
       +
       	"Coves/internal/db/postgres"

     

       10
       10
       +
       	"Coves/internal/jetstream"

     

       11
       11
       +
       )

     

       12
       12
       +
       

     

       13
       13
       +
       func TestUserIndexingFromJetstream(t *testing.T) {

     

       14
       14
       +
       	db := setupTestDB(t)

     

       15
       15
       +
       	defer db.Close()

     

       16
       16
       +
       

     

       17
       17
       +
       	// Wire up dependencies

     

       18
       18
       +
       	userRepo := postgres.NewUserRepository(db)

     

       19
       19
       +
       	userService := users.NewUserService(userRepo, "http://localhost:3001")

     

       20
       20
       +
       

     

       21
       21
       +
       	ctx := context.Background()

     

       22
       22
       +
       

     

       23
       23
       +
       	t.Run("Index new user from identity event", func(t *testing.T) {

     

       24
       24
       +
       		// Simulate an identity event from Jetstream

     

       25
       25
       +
       		event := jetstream.JetstreamEvent{

     

       26
       26
       +
       			Did:  "did:plc:jetstream123",

     

       27
       27
       +
       			Kind: "identity",

     

       28
       28
       +
       			Identity: &jetstream.IdentityEvent{

     

       29
       29
       +
       				Did:    "did:plc:jetstream123",

     

       30
       30
       +
       				Handle: "alice.jetstream.test",

     

       31
       31
       +
       				Seq:    12345,

     

       32
       32
       +
       				Time:   time.Now().Format(time.RFC3339),

     

       33
       33
       +
       			},

     

       34
       34
       +
       		}

     

       35
       35
       +
       

     

       36
       36
       +
       		consumer := jetstream.NewUserEventConsumer(userService, "", "")

     

       37
       37
       +
       

     

       38
       38
       +
       		// Handle the event

     

       39
       39
       +
       		err := consumer.HandleIdentityEventPublic(ctx, &event)

     

       40
       40
       +
       		if err != nil {

     

       41
       41
       +
       			t.Fatalf("failed to handle identity event: %v", err)

     

       42
       42
       +
       		}

     

       43
       43
       +
       

     

       44
       44
       +
       		// Verify user was indexed

     

       45
       45
       +
       		user, err := userService.GetUserByDID(ctx, "did:plc:jetstream123")

     

       46
       46
       +
       		if err != nil {

     

       47
       47
       +
       			t.Fatalf("failed to get indexed user: %v", err)

     

       48
       48
       +
       		}

     

       49
       49
       +
       

     

       50
       50
       +
       		if user.DID != "did:plc:jetstream123" {

     

       51
       51
       +
       			t.Errorf("expected DID did:plc:jetstream123, got %s", user.DID)

     

       52
       52
       +
       		}

     

       53
       53
       +
       

     

       54
       54
       +
       		if user.Handle != "alice.jetstream.test" {

     

       55
       55
       +
       			t.Errorf("expected handle alice.jetstream.test, got %s", user.Handle)

     

       56
       56
       +
       		}

     

       57
       57
       +
       	})

     

       58
       58
       +
       

     

       59
       59
       +
       	t.Run("Idempotent indexing - duplicate event", func(t *testing.T) {

     

       60
       60
       +
       		// Create a user first

     

       61
       61
       +
       		_, err := userService.CreateUser(ctx, users.CreateUserRequest{

     

       62
       62
       +
       			DID:    "did:plc:duplicate123",

     

       63
       63
       +
       			Handle: "duplicate.test",

     

       64
       64
       +
       			PDSURL: "https://bsky.social",

     

       65
       65
       +
       		})

     

       66
       66
       +
       		if err != nil {

     

       67
       67
       +
       			t.Fatalf("failed to create initial user: %v", err)

     

       68
       68
       +
       		}

     

       69
       69
       +
       

     

       70
       70
       +
       		// Simulate duplicate identity event

     

       71
       71
       +
       		event := jetstream.JetstreamEvent{

     

       72
       72
       +
       			Did:  "did:plc:duplicate123",

     

       73
       73
       +
       			Kind: "identity",

     

       74
       74
       +
       			Identity: &jetstream.IdentityEvent{

     

       75
       75
       +
       				Did:    "did:plc:duplicate123",

     

       76
       76
       +
       				Handle: "duplicate.test",

     

       77
       77
       +
       				Seq:    12346,

     

       78
       78
       +
       				Time:   time.Now().Format(time.RFC3339),

     

       79
       79
       +
       			},

     

       80
       80
       +
       		}

     

       81
       81
       +
       

     

       82
       82
       +
       		consumer := jetstream.NewUserEventConsumer(userService, "", "")

     

       83
       83
       +
       

     

       84
       84
       +
       		// Handle duplicate event - should not error

     

       85
       85
       +
       		err = consumer.HandleIdentityEventPublic(ctx, &event)

     

       86
       86
       +
       		if err != nil {

     

       87
       87
       +
       			t.Fatalf("duplicate event should be handled gracefully: %v", err)

     

       88
       88
       +
       		}

     

       89
       89
       +
       

     

       90
       90
       +
       		// Verify still only one user

     

       91
       91
       +
       		user, err := userService.GetUserByDID(ctx, "did:plc:duplicate123")

     

       92
       92
       +
       		if err != nil {

     

       93
       93
       +
       			t.Fatalf("failed to get user: %v", err)

     

       94
       94
       +
       		}

     

       95
       95
       +
       

     

       96
       96
       +
       		if user.Handle != "duplicate.test" {

     

       97
       97
       +
       			t.Errorf("expected handle duplicate.test, got %s", user.Handle)

     

       98
       98
       +
       		}

     

       99
       99
       +
       	})

     

       100
       100
       +
       

     

       101
       101
       +
       	t.Run("Index multiple users", func(t *testing.T) {

     

       102
       102
       +
       		consumer := jetstream.NewUserEventConsumer(userService, "", "")

     

       103
       103
       +
       

     

       104
       104
       +
       		users := []struct {

     

       105
       105
       +
       			did    string

     

       106
       106
       +
       			handle string

     

       107
       107
       +
       		}{

     

       108
       108
       +
       			{"did:plc:multi1", "user1.test"},

     

       109
       109
       +
       			{"did:plc:multi2", "user2.test"},

     

       110
       110
       +
       			{"did:plc:multi3", "user3.test"},

     

       111
       111
       +
       		}

     

       112
       112
       +
       

     

       113
       113
       +
       		for _, u := range users {

     

       114
       114
       +
       			event := jetstream.JetstreamEvent{

     

       115
       115
       +
       				Did:  u.did,

     

       116
       116
       +
       				Kind: "identity",

     

       117
       117
       +
       				Identity: &jetstream.IdentityEvent{

     

       118
       118
       +
       					Did:    u.did,

     

       119
       119
       +
       					Handle: u.handle,

     

       120
       120
       +
       					Seq:    12345,

     

       121
       121
       +
       					Time:   time.Now().Format(time.RFC3339),

     

       122
       122
       +
       				},

     

       123
       123
       +
       			}

     

       124
       124
       +
       

     

       125
       125
       +
       			err := consumer.HandleIdentityEventPublic(ctx, &event)

     

       126
       126
       +
       			if err != nil {

     

       127
       127
       +
       				t.Fatalf("failed to index user %s: %v", u.handle, err)

     

       128
       128
       +
       			}

     

       129
       129
       +
       		}

     

       130
       130
       +
       

     

       131
       131
       +
       		// Verify all users indexed

     

       132
       132
       +
       		for _, u := range users {

     

       133
       133
       +
       			user, err := userService.GetUserByDID(ctx, u.did)

     

       134
       134
       +
       			if err != nil {

     

       135
       135
       +
       				t.Fatalf("user %s not found: %v", u.did, err)

     

       136
       136
       +
       			}

     

       137
       137
       +
       

     

       138
       138
       +
       			if user.Handle != u.handle {

     

       139
       139
       +
       				t.Errorf("expected handle %s, got %s", u.handle, user.Handle)

     

       140
       140
       +
       			}

     

       141
       141
       +
       		}

     

       142
       142
       +
       	})

     

       143
       143
       +
       

     

       144
       144
       +
       	t.Run("Skip invalid events", func(t *testing.T) {

     

       145
       145
       +
       		consumer := jetstream.NewUserEventConsumer(userService, "", "")

     

       146
       146
       +
       

     

       147
       147
       +
       		// Missing DID

     

       148
       148
       +
       		invalidEvent1 := jetstream.JetstreamEvent{

     

       149
       149
       +
       			Did:  "",

     

       150
       150
       +
       			Kind: "identity",

     

       151
       151
       +
       			Identity: &jetstream.IdentityEvent{

     

       152
       152
       +
       				Did:    "",

     

       153
       153
       +
       				Handle: "invalid.test",

     

       154
       154
       +
       				Seq:    12345,

     

       155
       155
       +
       				Time:   time.Now().Format(time.RFC3339),

     

       156
       156
       +
       			},

     

       157
       157
       +
       		}

     

       158
       158
       +
       

     

       159
       159
       +
       		err := consumer.HandleIdentityEventPublic(ctx, &invalidEvent1)

     

       160
       160
       +
       		if err == nil {

     

       161
       161
       +
       			t.Error("expected error for missing DID, got nil")

     

       162
       162
       +
       		}

     

       163
       163
       +
       

     

       164
       164
       +
       		// Missing handle

     

       165
       165
       +
       		invalidEvent2 := jetstream.JetstreamEvent{

     

       166
       166
       +
       			Did:  "did:plc:invalid",

     

       167
       167
       +
       			Kind: "identity",

     

       168
       168
       +
       			Identity: &jetstream.IdentityEvent{

     

       169
       169
       +
       				Did:    "did:plc:invalid",

     

       170
       170
       +
       				Handle: "",

     

       171
       171
       +
       				Seq:    12345,

     

       172
       172
       +
       				Time:   time.Now().Format(time.RFC3339),

     

       173
       173
       +
       			},

     

       174
       174
       +
       		}

     

       175
       175
       +
       

     

       176
       176
       +
       		err = consumer.HandleIdentityEventPublic(ctx, &invalidEvent2)

     

       177
       177
       +
       		if err == nil {

     

       178
       178
       +
       			t.Error("expected error for missing handle, got nil")

     

       179
       179
       +
       		}

     

       180
       180
       +
       

     

       181
       181
       +
       		// Missing identity data

     

       182
       182
       +
       		invalidEvent3 := jetstream.JetstreamEvent{

     

       183
       183
       +
       			Did:      "did:plc:invalid2",

     

       184
       184
       +
       			Kind:     "identity",

     

       185
       185
       +
       			Identity: nil,

     

       186
       186
       +
       		}

     

       187
       187
       +
       

     

       188
       188
       +
       		err = consumer.HandleIdentityEventPublic(ctx, &invalidEvent3)

     

       189
       189
       +
       		if err == nil {

     

       190
       190
       +
       			t.Error("expected error for nil identity data, got nil")

     

       191
       191
       +
       		}

     

       192
       192
       +
       	})

     

       193
       193
       +
       }

     

       194
       194
       +
       

     

       195
       195
       +
       func TestUserServiceIdempotency(t *testing.T) {

     

       196
       196
       +
       	db := setupTestDB(t)

     

       197
       197
       +
       	defer db.Close()

     

       198
       198
       +
       

     

       199
       199
       +
       	userRepo := postgres.NewUserRepository(db)

     

       200
       200
       +
       	userService := users.NewUserService(userRepo, "http://localhost:3001")

     

       201
       201
       +
       	ctx := context.Background()

     

       202
       202
       +
       

     

       203
       203
       +
       	t.Run("CreateUser is idempotent for duplicate DID", func(t *testing.T) {

     

       204
       204
       +
       		req := users.CreateUserRequest{

     

       205
       205
       +
       			DID:    "did:plc:idempotent123",

     

       206
       206
       +
       			Handle: "idempotent.test",

     

       207
       207
       +
       			PDSURL: "https://bsky.social",

     

       208
       208
       +
       		}

     

       209
       209
       +
       

     

       210
       210
       +
       		// First creation

     

       211
       211
       +
       		user1, err := userService.CreateUser(ctx, req)

     

       212
       212
       +
       		if err != nil {

     

       213
       213
       +
       			t.Fatalf("first creation failed: %v", err)

     

       214
       214
       +
       		}

     

       215
       215
       +
       

     

       216
       216
       +
       		// Second creation with same DID - should return existing user, not error

     

       217
       217
       +
       		user2, err := userService.CreateUser(ctx, req)

     

       218
       218
       +
       		if err != nil {

     

       219
       219
       +
       			t.Fatalf("second creation should be idempotent: %v", err)

     

       220
       220
       +
       		}

     

       221
       221
       +
       

     

       222
       222
       +
       		if user1.DID != user2.DID {

     

       223
       223
       +
       			t.Errorf("expected same DID, got %s and %s", user1.DID, user2.DID)

     

       224
       224
       +
       		}

     

       225
       225
       +
       

     

       226
       226
       +
       		if user1.CreatedAt != user2.CreatedAt {

     

       227
       227
       +
       			t.Errorf("expected same user (same created_at), got different timestamps")

     

       228
       228
       +
       		}

     

       229
       229
       +
       	})

     

       230
       230
       +
       

     

       231
       231
       +
       	t.Run("CreateUser fails for duplicate handle with different DID", func(t *testing.T) {

     

       232
       232
       +
       		// Create first user

     

       233
       233
       +
       		_, err := userService.CreateUser(ctx, users.CreateUserRequest{

     

       234
       234
       +
       			DID:    "did:plc:handleconflict1",

     

       235
       235
       +
       			Handle: "conflicting.handle",

     

       236
       236
       +
       			PDSURL: "https://bsky.social",

     

       237
       237
       +
       		})

     

       238
       238
       +
       		if err != nil {

     

       239
       239
       +
       			t.Fatalf("first creation failed: %v", err)

     

       240
       240
       +
       		}

     

       241
       241
       +
       

     

       242
       242
       +
       		// Try to create different user with same handle

     

       243
       243
       +
       		_, err = userService.CreateUser(ctx, users.CreateUserRequest{

     

       244
       244
       +
       			DID:    "did:plc:handleconflict2",

     

       245
       245
       +
       			Handle: "conflicting.handle", // Same handle, different DID

     

       246
       246
       +
       			PDSURL: "https://bsky.social",

     

       247
       247
       +
       		})

     

       248
       248
       +
       

     

       249
       249
       +
       		if err == nil {

     

       250
       250
       +
       			t.Fatal("expected error for duplicate handle, got nil")

     

       251
       251
       +
       		}

     

       252
       252
       +
       

     

       253
       253
       +
       		if !contains(err.Error(), "handle already taken") {

     

       254
       254
       +
       			t.Errorf("expected 'handle already taken' error, got: %v", err)

     

       255
       255
       +
       		}

     

       256
       256
       +
       	})

     

       257
       257
       +
       }

     

       258
       258
       +
       

     

       259
       259
       +
       // Helper function

     

       260
       260
       +
       func contains(s, substr string) bool {

     

       261
       261
       +
       	return len(s) >= len(substr) && anySubstring(s, substr)

     

       262
       262
       +
       }

     

       263
       263
       +
       

     

       264
       264
       +
       func anySubstring(s, substr string) bool {

     

       265
       265
       +
       	for i := 0; i <= len(s)-len(substr); i++ {

     

       266
       266
       +
       		if s[i:i+len(substr)] == substr {

     

       267
       267
       +
       			return true

     

       268
       268
       +
       		}

     

       269
       269
       +
       	}

     

       270
       270
       +
       	return false

     

       271
       271
       +
       }