commit af18e2996b7086eaba6ddd2dc3a2af540b8d7014 · bretton.dev/coves

+48 -38

Makefile

···

       20
       20
        
       		/^##@/ { printf "\n$(YELLOW)%s$(RESET)\n", substr($$0, 5) }' $(MAKEFILE_LIST)

     

       21
       21
        
       	@echo ""

     

       22
       22
        
       

     

       23
       23
       -
       ##@ Local Development (atProto Stack)

     

       23
       23
       +
       ##@ Local Development (All-in-One)

     

       24
       24
        
       

     

       25
       25
       -
       dev-up: ## Start PDS for local development

     

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

     

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

     

       27
       27
       -
       	@echo "$(YELLOW)Note: Make sure PostgreSQL is running on port 5433$(RESET)"

     

       28
       28
       -
       	@echo "Run 'make dev-db-up' if database is not running"

     

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

     

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

     

       30
       28
        
       	@echo ""

     

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

     

       32
       30
        
       	@echo ""

     

       33
       31
        
       	@echo "Services available at:"

     

       32
       32
       +
       	@echo "  - PostgreSQL:        localhost:5433"

     

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

     

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

     

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

     

       37
       36
        
       	@echo ""

     

       38
       37
        
       	@echo "Run 'make dev-logs' to view logs"

     

       39
       38
        
       

     

       40
       40
       -
       dev-down: ## Stop the atProto development stack

     

       39
       39
       +
       dev-down: ## Stop all development services

     

       41
       40
        
       	@echo "$(YELLOW)Stopping Coves development stack...$(RESET)"

     

       42
       42
       -
       	@docker-compose -f docker-compose.dev.yml down

     

       41
       41
       +
       	@docker-compose -f docker-compose.dev.yml --env-file .env.dev down

     

       43
       42
        
       	@echo "$(GREEN)✓ Development stack stopped$(RESET)"

     

       44
       43
        
       

     

       45
       44
        
       dev-logs: ## Tail logs from all development services

     

       46
       46
       -
       	@docker-compose -f docker-compose.dev.yml logs -f

     

       45
       45
       +
       	@docker-compose -f docker-compose.dev.yml --env-file .env.dev logs -f

     

       47
       46
        
       

     

       48
       47
        
       dev-status: ## Show status of all development containers

     

       49
       48
        
       	@echo "$(CYAN)Development Stack Status:$(RESET)"

     

       50
       50
       -
       	@docker-compose -f docker-compose.dev.yml ps

     

       51
       51
       -
       	@echo ""

     

       52
       52
       -
       	@echo "$(CYAN)Database Status:$(RESET)"

     

       53
       53
       -
       	@cd internal/db/local_dev_db_compose && docker-compose ps

     

       49
       49
       +
       	@docker-compose -f docker-compose.dev.yml --env-file .env.dev ps

     

       54
       50
        
       

     

       55
       51
        
       dev-reset: ## Nuclear option - stop everything and remove all volumes

     

       56
       56
       -
       	@echo "$(YELLOW)⚠️  WARNING: This will delete all PDS data and volumes!$(RESET)"

     

       52
       52
       +
       	@echo "$(YELLOW)⚠️  WARNING: This will delete ALL data (PostgreSQL + PDS)!$(RESET)"

     

       57
       53
        
       	@read -p "Are you sure? (y/N): " confirm && [ "$$confirm" = "y" ] || exit 1

     

       58
       54
        
       	@echo "$(YELLOW)Stopping and removing containers and volumes...$(RESET)"

     

       59
       59
       -
       	@docker-compose -f docker-compose.dev.yml down -v

     

       55
       55
       +
       	@docker-compose -f docker-compose.dev.yml --env-file .env.dev down -v

     

       60
       56
        
       	@echo "$(GREEN)✓ Reset complete - all data removed$(RESET)"

     

       61
       57
        
       	@echo "Run 'make dev-up' to start fresh"

     

       62
       58
        
       

     

       63
       59
        
       ##@ Database Management

     

       64
       60
        
       

     

       65
       65
       -
       dev-db-up: ## Start local PostgreSQL database (port 5433)

     

       66
       66
       -
       	@echo "$(GREEN)Starting local PostgreSQL database...$(RESET)"

     

       67
       67
       -
       	@cd internal/db/local_dev_db_compose && docker-compose up -d

     

       68
       68
       -
       	@echo "$(GREEN)✓ Database started on port 5433$(RESET)"

     

       69
       69
       -
       	@echo "Connection: postgresql://dev_user:dev_password@localhost:5433/coves_dev"

     

       61
       61
       +
       db-shell: ## Open PostgreSQL shell for development database

     

       62
       62
       +
       	@echo "$(CYAN)Connecting to development database...$(RESET)"

     

       63
       63
       +
       	@docker exec -it coves-dev-postgres psql -U dev_user -d coves_dev

     

       70
       64
        
       

     

       71
       71
       -
       dev-db-down: ## Stop local PostgreSQL database

     

       72
       72
       -
       	@echo "$(YELLOW)Stopping local PostgreSQL database...$(RESET)"

     

       73
       73
       -
       	@cd internal/db/local_dev_db_compose && docker-compose down

     

       74
       74
       -
       	@echo "$(GREEN)✓ Database stopped$(RESET)"

     

       65
       65
       +
       db-migrate: ## Run database migrations

     

       66
       66
       +
       	@echo "$(GREEN)Running database migrations...$(RESET)"

     

       67
       67
       +
       	@goose -dir internal/db/migrations postgres "postgresql://dev_user:dev_password@localhost:5433/coves_dev?sslmode=disable" up

     

       68
       68
       +
       	@echo "$(GREEN)✓ Migrations complete$(RESET)"

     

       75
       69
        
       

     

       76
       76
       -
       dev-db-reset: ## Reset database (delete all data and restart)

     

       70
       70
       +
       db-migrate-down: ## Rollback last migration

     

       71
       71
       +
       	@echo "$(YELLOW)Rolling back last migration...$(RESET)"

     

       72
       72
       +
       	@goose -dir internal/db/migrations postgres "postgresql://dev_user:dev_password@localhost:5433/coves_dev?sslmode=disable" down

     

       73
       73
       +
       	@echo "$(GREEN)✓ Rollback complete$(RESET)"

     

       74
       74
       +
       

     

       75
       75
       +
       db-reset: ## Reset database (delete all data and re-run migrations)

     

       77
       76
        
       	@echo "$(YELLOW)⚠️  WARNING: This will delete all database data!$(RESET)"

     

       78
       77
        
       	@read -p "Are you sure? (y/N): " confirm && [ "$$confirm" = "y" ] || exit 1

     

       79
       78
        
       	@echo "$(YELLOW)Resetting database...$(RESET)"

     

       80
       80
       -
       	@cd internal/db/local_dev_db_compose && docker-compose down -v

     

       81
       81
       -
       	@cd internal/db/local_dev_db_compose && docker-compose up -d

     

       79
       79
       +
       	@docker-compose -f docker-compose.dev.yml --env-file .env.dev rm -sf postgres

     

       80
       80
       +
       	@docker volume rm coves-dev-postgres-data || true

     

       81
       81
       +
       	@docker-compose -f docker-compose.dev.yml --env-file .env.dev up -d postgres

     

       82
       82
       +
       	@echo "Waiting for PostgreSQL to be ready..."

     

       83
       83
       +
       	@sleep 3

     

       84
       84
       +
       	@make db-migrate

     

       82
       85
        
       	@echo "$(GREEN)✓ Database reset complete$(RESET)"

     

       83
       86
        
       

     

       84
       87
        
       ##@ Testing

     

       85
       88
        
       

     

       86
       89
        
       test: ## Run all tests with test database

     

       87
       90
        
       	@echo "$(GREEN)Starting test database...$(RESET)"

     

       88
       88
       -
       	@cd internal/db/test_db_compose && ./start-test-db.sh

     

       91
       91
       +
       	@docker-compose -f docker-compose.dev.yml --env-file .env.dev --profile test up -d postgres-test

     

       92
       92
       +
       	@echo "Waiting for test database to be ready..."

     

       93
       93
       +
       	@sleep 3

     

       94
       94
       +
       	@echo "$(GREEN)Running migrations on test database...$(RESET)"

     

       95
       95
       +
       	@goose -dir internal/db/migrations postgres "postgresql://test_user:test_password@localhost:5434/coves_test?sslmode=disable" up || true

     

       89
       96
        
       	@echo "$(GREEN)Running tests...$(RESET)"

     

       90
       90
       -
       	@./run-tests.sh

     

       97
       97
       +
       	@TEST_DATABASE_URL="postgresql://test_user:test_password@localhost:5434/coves_test?sslmode=disable" go test ./... -v

     

       91
       98
        
       	@echo "$(GREEN)✓ Tests complete$(RESET)"

     

       92
       99
        
       

     

       93
       100
        
       test-db-reset: ## Reset test database

     

       94
       101
        
       	@echo "$(GREEN)Resetting test database...$(RESET)"

     

       95
       95
       -
       	@cd internal/db/test_db_compose && ./reset-test-db.sh

     

       102
       102
       +
       	@docker-compose -f docker-compose.dev.yml --env-file .env.dev --profile test rm -sf postgres-test

     

       103
       103
       +
       	@docker volume rm coves-test-postgres-data || true

     

       104
       104
       +
       	@docker-compose -f docker-compose.dev.yml --env-file .env.dev --profile test up -d postgres-test

     

       105
       105
       +
       	@echo "Waiting for PostgreSQL to be ready..."

     

       106
       106
       +
       	@sleep 3

     

       107
       107
       +
       	@goose -dir internal/db/migrations postgres "postgresql://test_user:test_password@localhost:5434/coves_test?sslmode=disable" up || true

     

       96
       108
        
       	@echo "$(GREEN)✓ Test database reset$(RESET)"

     

       109
       109
       +
       

     

       110
       110
       +
       test-db-stop: ## Stop test database

     

       111
       111
       +
       	@docker-compose -f docker-compose.dev.yml --env-file .env.dev --profile test stop postgres-test

     

       112
       112
       +
       	@echo "$(GREEN)✓ Test database stopped$(RESET)"

     

       97
       113
        
       

     

       98
       114
        
       ##@ Build & Run

     

       99
       115
        
       

     
···

       118
       134
        
       	@echo "$(YELLOW)⚠️  WARNING: This will remove ALL Docker volumes!$(RESET)"

     

       119
       135
        
       	@read -p "Are you sure? (y/N): " confirm && [ "$$confirm" = "y" ] || exit 1

     

       120
       136
        
       	@make dev-reset

     

       121
       121
       -
       	@make dev-db-reset

     

       122
       137
        
       	@echo "$(GREEN)✓ All clean$(RESET)"

     

       123
       138
        
       

     

       124
       139
        
       ##@ Workflows (Common Tasks)

     

       125
       140
        
       

     

       126
       126
       -
       fresh-start: ## Complete fresh start (reset DB, reset stack, start everything)

     

       141
       141
       +
       fresh-start: ## Complete fresh start (reset everything, start clean)

     

       127
       142
        
       	@echo "$(CYAN)Starting fresh development environment...$(RESET)"

     

       128
       128
       -
       	@make dev-db-reset

     

       129
       143
        
       	@make dev-reset || true

     

       130
       144
        
       	@sleep 2

     

       131
       131
       -
       	@make dev-db-up

     

       132
       132
       -
       	@sleep 2

     

       133
       145
        
       	@make dev-up

     

       146
       146
       +
       	@sleep 3

     

       147
       147
       +
       	@make db-migrate

     

       134
       148
        
       	@echo ""

     

       135
       149
        
       	@echo "$(GREEN)✓ Fresh environment ready!$(RESET)"

     

       136
       150
        
       	@make dev-status

     
···

       145
       159
        
       	@echo "$(GREEN)Validating Lexicon schemas...$(RESET)"

     

       146
       160
        
       	@./validate-lexicon

     

       147
       161
        
       	@echo "$(GREEN)✓ Lexicon validation complete$(RESET)"

     

       148
       148
       -
       

     

       149
       149
       -
       db-shell: ## Open PostgreSQL shell for local database

     

       150
       150
       -
       	@echo "$(CYAN)Connecting to local database...$(RESET)"

     

       151
       151
       -
       	@PGPASSWORD=dev_password psql -h localhost -p 5433 -U dev_user -d coves_dev

     

       152
       162
        
       

     

       153
       163
        
       ##@ Documentation

     

       154
       164

+342

PRD.md

···

       1
       1
       +
       # Coves Product Requirements Document (PRD)

     

       2
       2
       +
       ## Digital Community Infrastructure Platform

     

       3
       3
       +
       

     

       4
       4
       +
       ---

     

       5
       5
       +
       

     

       6
       6
       +
       ## 1. Executive Summary

     

       7
       7
       +
       

     

       8
       8
       +
       **Vision**: A federated forum platform that ensures a solid framework for digital community building and meaningful information discussion.

     

       9
       9
       +
       

     

       10
       10
       +
       **Core Values**:

     

       11
       11
       +
       - User sovereignty through data portability

     

       12
       12
       +
       - Community autonomy and self-governance

     

       13
       13
       +
       - Cross-platform interoperability

     

       14
       14
       +
       

     

       15
       15
       +
       ---

     

       16
       16
       +
       

     

       17
       17
       +
       ## 2. MVP Scope Definition

     

       18
       18
       +
       

     

       19
       19
       +
       ### Phase 1: Core Forum Platform (Web)

     

       20
       20
       +
       

     

       21
       21
       +
       #### Must Have:

     

       22
       22
       +
       - **Indigo PDS Integration** - Use existing atProto infrastructure (no CAR file reimplementation!)

     

       23
       23
       +
       - User registration with phone verification (verified badge)

     

       24
       24
       +
       - Community creation, subscription, and discovery

     

       25
       25
       +
       - Post creation (text initially, then image/video/article)

     

       26
       26
       +
       - Threaded comments with upvoting

     

       27
       27
       +
       - Three feed types:

     

       28
       28
       +
         - **Home**: Personalized based on subscriptions with 1-5 visibility slider per community

     

       29
       29
       +
         - **All**: Global content discovery

     

       30
       30
       +
         - **Community**: Standard forum sorting (hot/new/top)

     

       31
       31
       +
       - Read state tracking (hide read posts, history tab)

     

       32
       32
       +
       - Content tagging system (helpful/spam/hostile)

     

       33
       33
       +
       - User blocking capabilities

     

       34
       34
       +
       

     

       35
       35
       +
       #### Defer to Post-MVP:

     

       36
       36
       +
       - Community wikis

     

       37
       37
       +
       - Advanced reputation system

     

       38
       38
       +
       - Sortition/tribunal moderation

     

       39
       39
       +
       - Edit history tracking

     

       40
       40
       +
       - Plugin/bot system

     

       41
       41
       +
       

     

       42
       42
       +
       ### Phase 2: Federation (MVP+)

     

       43
       43
       +
       - Bluesky post display (read-only via Indigo firehose)

     

       44
       44
       +
       - ActivityPub bidirectional support

     

       45
       45
       +
       - Federation source indicators

     

       46
       46
       +
       

     

       47
       47
       +
       ### Phase 3: Mobile Apps (Separate Repo)

     

       48
       48
       +
       - iOS/Android native apps

     

       49
       49
       +
       - TikTok-style horizontal scrolling feed

     

       50
       50
       +
       - Offline-first architecture

     

       51
       51
       +
       - Push notifications

     

       52
       52
       +
       

     

       53
       53
       +
       ---

     

       54
       54
       +
       

     

       55
       55
       +
       ## 3. Technical Architecture

     

       56
       56
       +
       

     

       57
       57
       +
       ### Backend Stack:

     

       58
       58
       +
       - **PDS Layer**: Indigo PDS implementation (handles atProto, CAR files, firehose)

     

       59
       59
       +
       - **Application Layer**: Go services for Coves-specific features

     

       60
       60
       +
       - **Databases**:

     

       61
       61
       +
         - Indigo PDS's PostgreSQL (user repos, DID management)

     

       62
       62
       +
         - Separate PostgreSQL for AppView (queries, read states, community data)

     

       63
       63
       +
       - **APIs**: XRPC protocol (leverage Indigo's implementation)

     

       64
       64
       +
       - **Identity**: atProto DIDs with phone verification

     

       65
       65
       +
       

     

       66
       66
       +
       ### Frontend Stack:

     

       67
       67
       +
       - **Web**: React/Next.js

     

       68
       68
       +
       - **Mobile**: React Native or Flutter (separate repository)

     

       69
       69
       +
       - **State Management**: Zustand/Redux with offline sync

     

       70
       70
       +
       

     

       71
       71
       +
       ---

     

       72
       72
       +
       

     

       73
       73
       +
       ## 4. Development Roadmap

     

       74
       74
       +
       

     

       75
       75
       +
       ### Week 1-2: Foundation

     

       76
       76
       +
       - Deploy Indigo PDS instance

     

       77
       77
       +
       - Set up AppView database

     

       78
       78
       +
       - Create core Lexicon schemas (community, post, comment)

     

       79
       79
       +
       - Implement phone verification flow

     

       80
       80
       +
       

     

       81
       81
       +
       ### Week 3-4: User & Identity

     

       82
       82
       +
       - User registration/login via Indigo PDS

     

       83
       83
       +
       - Profile management

     

       84
       84
       +
       - DID resolution and handle system

     

       85
       85
       +
       - Basic user settings

     

       86
       86
       +
       

     

       87
       87
       +
       ### Week 5-6: Communities

     

       88
       88
       +
       - Community CRUD operations

     

       89
       89
       +
       - Subscription management

     

       90
       90
       +
       - Community discovery page

     

       91
       91
       +
       - Basic moderation tools

     

       92
       92
       +
       

     

       93
       93
       +
       ### Week 7-8: Content Creation

     

       94
       94
       +
       - Post creation (text, then multimedia)

     

       95
       95
       +
       - Comment threads

     

       96
       96
       +
       - Upvoting system

     

       97
       97
       +
       - Content tagging

     

       98
       98
       +
       

     

       99
       99
       +
       ### Week 9-10: Feed System

     

       100
       100
       +
       - Home feed with subscription slider

     

       101
       101
       +
       - Community feeds with sorting

     

       102
       102
       +
       - All/global feed

     

       103
       103
       +
       - Read state tracking and history

     

       104
       104
       +
       

     

       105
       105
       +
       ### Week 11-12: Polish & Testing

     

       106
       106
       +
       - Search functionality

     

       107
       107
       +
       - User blocking

     

       108
       108
       +
       - Performance optimization

     

       109
       109
       +
       - Security audit

     

       110
       110
       +
       - Alpha deployment

     

       111
       111
       +
       

     

       112
       112
       +
       ### Post-MVP: Federation

     

       113
       113
       +
       - Subscribe to Indigo firehose for Bluesky content

     

       114
       114
       +
       - ActivityPub adapter service

     

       115
       115
       +
       - Cross-platform user mapping

     

       116
       116
       +
       

     

       117
       117
       +
       ---

     

       118
       118
       +
       

     

       119
       119
       +
       ## 5. Mobile Application Strategy

     

       120
       120
       +
       

     

       121
       121
       +
       **Approach**: Separate repository, API-first design

     

       122
       122
       +
       

     

       123
       123
       +
       ### MVP Features:

     

       124
       124
       +
       - Horizontal swipe navigation between posts

     

       125
       125
       +
       - Offline caching with background sync

     

       126
       126
       +
       - Push notifications for interactions

     

       127
       127
       +
       - Native performance optimization

     

       128
       128
       +
       

     

       129
       129
       +
       **Timeline**: Begin after web MVP validation (Month 4-6)

     

       130
       130
       +
       

     

       131
       131
       +
       ---

     

       132
       132
       +
       

     

       133
       133
       +
       ## 6. Key Technical Decisions

     

       134
       134
       +
       

     

       135
       135
       +
       ### Leveraging Indigo:

     

       136
       136
       +
       - Use Indigo PDS for all atProto infrastructure

     

       137
       137
       +
       - Subscribe to Indigo firehose instead of building our own

     

       138
       138
       +
       - Focus engineering on Coves-specific features

     

       139
       139
       +
       

     

       140
       140
       +
       ### Data Architecture:

     

       141
       141
       +
       - User content → Indigo PDS (portable)

     

       142
       142
       +
       - Read states/analytics → AppView (non-portable, privacy-focused)

     

       143
       143
       +
       - No ads, tracking, or user data monetization

     

       144
       144
       +
       

     

       145
       145
       +
       ### Open Source:

     

       146
       146
       +
       - MIT license

     

       147
       147
       +
       - Public repository

     

       148
       148
       +
       - Community contributions welcome

     

       149
       149
       +
       

     

       150
       150
       +
       ---

     

       151
       151
       +
       

     

       152
       152
       +
       ## 7. Success Metrics

     

       153
       153
       +
       

     

       154
       154
       +
       ### MVP Launch (3 months):

     

       155
       155
       +
       - 50+ active communities

     

       156
       156
       +
       - 500+ registered users

     

       157
       157
       +
       - <2 second page loads

     

       158
       158
       +
       - 99.5% uptime

     

       159
       159
       +
       - Successful Bluesky content display

     

       160
       160
       +
       

     

       161
       161
       +
       ### 6 Month Goals:

     

       162
       162
       +
       - 500+ communities

     

       163
       163
       +
       - 5,000+ MAU

     

       164
       164
       +
       - Mobile app launched

     

       165
       165
       +
       - Federation with 3+ platforms

     

       166
       166
       +
       

     

       167
       167
       +
       ---

     

       168
       168
       +
       

     

       169
       169
       +
       ## 8. Resource Requirements

     

       170
       170
       +
       

     

       171
       171
       +
       ### Team:

     

       172
       172
       +
       - 2 Backend Engineers (Go, atProto experience)

     

       173
       173
       +
       - 1 Frontend Engineer (React)

     

       174
       174
       +
       - 1 DevOps (part-time, Indigo deployment)

     

       175
       175
       +
       - 1 Mobile Developer (post-MVP)

     

       176
       176
       +
       

     

       177
       177
       +
       ### Infrastructure:

     

       178
       178
       +
       - Indigo PDS instance: ~$200/month

     

       179
       179
       +
       - AppView database: ~$100/month

     

       180
       180
       +
       - CDN/Storage: ~$100/month

     

       181
       181
       +
       - **Total**: ~$400-500/month initially

     

       182
       182
       +
       

     

       183
       183
       +
       ---

     

       184
       184
       +
       

     

       185
       185
       +
       ## 9. Risk Mitigation

     

       186
       186
       +
       

     

       187
       187
       +
       | Risk | Mitigation |

     

       188
       188
       +
       |------|------------|

     

       189
       189
       +
       | Indigo PDS complexity | Start with vanilla deployment, customize gradually |

     

       190
       190
       +
       | Moderation at scale | Launch with simple tagging, evolve based on community needs |

     

       191
       191
       +
       | Federation conflicts | Phased rollout, Bluesky read-only first |

     

       192
       192
       +
       | Mobile development | Consider PWA if native timeline slips |

     

       193
       193
       +
       | Community adoption | Focus on unique features (read states, visibility slider) |

     

       194
       194
       +
       

     

       195
       195
       +
       ---

     

       196
       196
       +
       

     

       197
       197
       +
       ## 10. Immediate Next Steps

     

       198
       198
       +
       

     

       199
       199
       +
       ### Week 1:

     

       200
       200
       +
       - Deploy Indigo PDS test instance

     

       201
       201
       +
       - Design Coves-specific Lexicon schemas

     

       202
       202
       +
       - Set up development environment

     

       203
       203
       +
       

     

       204
       204
       +
       ### Week 2:

     

       205
       205
       +
       - Implement phone verification service

     

       206
       206
       +
       - Create first XRPC endpoints for communities

     

       207
       207
       +
       - Begin frontend scaffolding

     

       208
       208
       +
       

     

       209
       209
       +
       ### Week 3:

     

       210
       210
       +
       - User registration flow

     

       211
       211
       +
       - Community creation

     

       212
       212
       +
       - Basic post functionality

     

       213
       213
       +
       

     

       214
       214
       +
       ---

     

       215
       215
       +
       

     

       216
       216
       +
       ## 11. Long-term Vision (Post-MVP)

     

       217
       217
       +
       

     

       218
       218
       +
       - Sortition-based moderation experiments

     

       219
       219
       +
       - Community wikis and documentation

     

       220
       220
       +
       - Plugin system for community bots

     

       221
       221
       +
       - Advanced reputation mechanics

     

       222
       222
       +
       - Full ActivityPub federation

     

       223
       223
       +
       - Possible Mastodon integration

     

       224
       224
       +
       - Community forking via DIDs

     

       225
       225
       +
       - Incognito browsing mode

     

       226
       226
       +
       

     

       227
       227
       +
       ---

     

       228
       228
       +
       

     

       229
       229
       +
       ## 12. Differentiators

     

       230
       230
       +
       

     

       231
       231
       +
       **Why Coves vs Reddit/Lemmy/Discourse?**

     

       232
       232
       +
       - True data portability via atProto

     

       233
       233
       +
       - Subscription visibility slider (unique feed control)

     

       234
       234
       +
       - Read state tracking across devices

     

       235
       235
       +
       - Phone verification for trust

     

       236
       236
       +
       - Federation-first, not an afterthought

     

       237
       237
       +
       - Community-driven moderation models

     

       238
       238
       +
       - No corporate ownership or ads

     

       239
       239
       +
       

     

       240
       240
       +
       ---

     

       241
       241
       +
       

     

       242
       242
       +
       ## Feature Details from Domain Knowledge

     

       243
       243
       +
       

     

       244
       244
       +
       ### Feed System Specifications

     

       245
       245
       +
       

     

       246
       246
       +
       #### Home Feed:

     

       247
       247
       +
       - **UI**: TikTok-style scrollable feed (horizontal swipe)

     

       248
       248
       +
       - **Personalization**:

     

       249
       249
       +
         - Subscription slider (1-5 scale per community)

     

       250
       250
       +
           - 1 = Only best/most popular content

     

       251
       251
       +
           - 5 = Show all content

     

       252
       252
       +
         - Read state tracking with history tab

     

       253
       253
       +
         - Read history stored in AppView (not user repos)

     

       254
       254
       +
       

     

       255
       255
       +
       #### Community Feed:

     

       256
       256
       +
       - Standard sorting: hot, top (day/month/year), new

     

       257
       257
       +
       - Respects read state

     

       258
       258
       +
       - Community-specific rules application

     

       259
       259
       +
       

     

       260
       260
       +
       ### Community Features

     

       261
       261
       +
       

     

       262
       262
       +
       #### Core Capabilities:

     

       263
       263
       +
       - Creation and blocking

     

       264
       264
       +
       - Wiki maintenance

     

       265
       265
       +
       - NSFW toggling

     

       266
       266
       +
       - Subscription management

     

       267
       267
       +
       

     

       268
       268
       +
       #### Reputation System:

     

       269
       269
       +
       - Gained through posts, comments, positive tags

     

       270
       270
       +
       - Affects member access levels

     

       271
       271
       +
       - Influences comment ordering

     

       272
       272
       +
       - Voting weight based on reputation

     

       273
       273
       +
       

     

       274
       274
       +
       #### Rules System:

     

       275
       275
       +
       - Democratic rule voting

     

       276
       276
       +
       - Post type restrictions (e.g., text-only)

     

       277
       277
       +
       - Website blocklists

     

       278
       278
       +
       - Geolocation restrictions

     

       279
       279
       +
       

     

       280
       280
       +
       #### Moderation Models:

     

       281
       281
       +
       1. **Sortition-Based**:

     

       282
       282
       +
          - Tag-based removal with tribunal review

     

       283
       283
       +
          - Minimum reputation for tribunal service

     

       284
       284
       +
       

     

       285
       285
       +
       2. **Traditional**:

     

       286
       286
       +
          - Moderator hierarchy

     

       287
       287
       +
          - Community override capability

     

       288
       288
       +
          - Hybrid approach with user feedback

     

       289
       289
       +
       

     

       290
       290
       +
       ### Post System

     

       291
       291
       +
       

     

       292
       292
       +
       #### Types:

     

       293
       293
       +
       - Text (MVP)

     

       294
       294
       +
       - Video

     

       295
       295
       +
       - Image

     

       296
       296
       +
       - Article

     

       297
       297
       +
       - Microblog (for Bluesky posts)

     

       298
       298
       +
       

     

       299
       299
       +
       #### Features:

     

       300
       300
       +
       - Upvoting

     

       301
       301
       +
       - Tagging (helpful/spam/hostile)

     

       302
       302
       +
       - Share tracking

     

       303
       303
       +
       - Comment ownership

     

       304
       304
       +
       - Federation source indicators

     

       305
       305
       +
       

     

       306
       306
       +
       ### User System

     

       307
       307
       +
       

     

       308
       308
       +
       #### Identity:

     

       309
       309
       +
       - Phone verification (grants verified status)

     

       310
       310
       +
       - atProto DID system

     

       311
       311
       +
       - Platform federation tracking

     

       312
       312
       +
       

     

       313
       313
       +
       #### Username System:

     

       314
       314
       +
       - Random generation patterns:

     

       315
       315
       +
         - "AdjectiveNoun" (e.g., "BraveEagle")

     

       316
       316
       +
         - "AdjectiveAdjectiveNoun" (e.g., "SmallQuietMouse")

     

       317
       317
       +
       

     

       318
       318
       +
       #### Features:

     

       319
       319
       +
       - User blocking

     

       320
       320
       +
       - Notification muting

     

       321
       321
       +
       - Post saving

     

       322
       322
       +
       - View history

     

       323
       323
       +
       

     

       324
       324
       +
       ### Federation Approach

     

       325
       325
       +
       

     

       326
       326
       +
       #### atProto (Bluesky):

     

       327
       327
       +
       - Display posts inline as references

     

       328
       328
       +
       - Posts-only initially (comments later)

     

       329
       329
       +
       

     

       330
       330
       +
       #### ActivityPub:

     

       331
       331
       +
       - Two-way compatibility

     

       332
       332
       +
       - Instance → Hub mapping

     

       333
       333
       +
       - Community mapping

     

       334
       334
       +
       - User DID assignment

     

       335
       335
       +
       - Action translation to Coves lexicon

     

       336
       336
       +
       

     

       337
       337
       +
       ---

     

       338
       338
       +
       

     

       339
       339
       +
       *Last Updated: January 2025*

     

       340
       340
       +
       *Version: 1.0*

     

       341
       341
       +
       

     

       342
       342
       +
       This PRD focuses on shipping a working MVP in 3 months by leveraging existing Indigo infrastructure, then iterating based on real community feedback.

+2 -29

cmd/server/main.go

···

       11
       11
        
       	"github.com/go-chi/chi/v5/middleware"

     

       12
       12
        
       	_ "github.com/lib/pq"

     

       13
       13
        
       	"github.com/pressly/goose/v3"

     

       14
       14
       -
       	"gorm.io/driver/postgres"

     

       15
       15
       -
       	"gorm.io/gorm"

     

       16
       14
        
       

     

       17
       15
        
       	"Coves/internal/api/routes"

     

       18
       18
       -
       	"Coves/internal/atproto/carstore"

     

       19
       19
       -
       	"Coves/internal/core/repository"

     

       20
       16
        
       	"Coves/internal/core/users"

     

       21
       17
        
       	postgresRepo "Coves/internal/db/postgres"

     

       22
       18
        
       )

     
···

       51
       47
        
       	r.Use(middleware.Recoverer)

     

       52
       48
        
       	r.Use(middleware.RequestID)

     

       53
       49
        
       

     

       54
       54
       -
       	// Initialize GORM

     

       55
       55
       -
       	gormDB, err := gorm.Open(postgres.New(postgres.Config{

     

       56
       56
       -
       		Conn: db,

     

       57
       57
       -
       	}), &gorm.Config{

     

       58
       58
       -
       		DisableForeignKeyConstraintWhenMigrating: true,

     

       59
       59
       -
       		PrepareStmt:                              true, // Enable prepared statements for better performance

     

       60
       60
       -
       	})

     

       61
       61
       -
       	if err != nil {

     

       62
       62
       -
       		log.Fatal("Failed to initialize GORM:", err)

     

       63
       63
       -
       	}

     

       64
       64
       -
       

     

       65
       50
        
       	// Initialize repositories

     

       66
       51
        
       	userRepo := postgresRepo.NewUserRepository(db)

     

       67
       67
       -
       	_ = users.NewUserService(userRepo) // TODO: Use when UserRoutes is fixed

     

       68
       68
       -
       

     

       69
       69
       -
       	// Initialize carstore for ATProto repository storage

     

       70
       70
       -
       	carDirs := []string{"./data/carstore"}

     

       71
       71
       -
       	repoStore, err := carstore.NewRepoStore(gormDB, carDirs)

     

       72
       72
       -
       	if err != nil {

     

       73
       73
       -
       		log.Fatal("Failed to initialize repo store:", err)

     

       74
       74
       -
       	}

     

       75
       75
       -
       

     

       76
       76
       -
       	repositoryRepo := postgresRepo.NewRepositoryRepo(db)

     

       77
       77
       -
       	repositoryService := repository.NewService(repositoryRepo, repoStore)

     

       52
       52
       +
       	userService := users.NewUserService(userRepo)

     

       78
       53
        
       

     

       79
       54
        
       	// Mount routes

     

       80
       80
       -
       	// TODO: Fix UserRoutes to accept *UserService

     

       81
       81
       -
       	// r.Mount("/api/users", routes.UserRoutes(userService))

     

       82
       82
       -
       	r.Mount("/", routes.RepositoryRoutes(repositoryService))

     

       55
       55
       +
       	r.Mount("/api/users", routes.UserRoutes(userService))

     

       83
       56
        
       

     

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

     

       85
       58
        
       		w.WriteHeader(http.StatusOK)

+68 -14

docker-compose.dev.yml

···

       1
       1
        
       version: '3.8'

     

       2
       2
        
       

     

       3
       3
        
       # Coves Local Development Stack

     

       4
       4
       -
       # Simple setup: PDS + AppView (no relay needed for local dev)

     

       5
       5
       -
       # AppView subscribes directly to PDS firehose at ws://localhost:3001/xrpc/com.atproto.sync.subscribeRepos

     

       6
       6
       -
       # Ports configured to avoid conflicts with production PDS on :3000

     

       4
       4
       +
       # All-in-one setup: PDS + PostgreSQL + optional Relay

     

       5
       5
       +
       #

     

       6
       6
       +
       # Usage:

     

       7
       7
       +
       #   make dev-up              # Start PDS + PostgreSQL

     

       8
       8
       +
       #   make dev-down            # Stop everything

     

       9
       9
       +
       #   docker-compose up relay  # Optional: start with relay

     

       10
       10
       +
       #

     

       11
       11
       +
       # Profiles:

     

       12
       12
       +
       #   - default: PDS + PostgreSQL (dev database on port 5433)

     

       13
       13
       +
       #   - test: PostgreSQL test database (port 5434)

     

       14
       14
       +
       #   - relay: BigSky relay (optional, will crawl entire network!)

     

       7
       15
        
       

     

       8
       16
        
       services:

     

       17
       17
       +
         # PostgreSQL Database (Port 5433)

     

       18
       18
       +
         # Used by Coves AppView for indexing data from firehose

     

       19
       19
       +
         postgres:

     

       20
       20
       +
           image: postgres:15

     

       21
       21
       +
           container_name: coves-dev-postgres

     

       22
       22
       +
           ports:

     

       23
       23
       +
             - "5433:5432"

     

       24
       24
       +
           environment:

     

       25
       25
       +
             POSTGRES_DB: ${POSTGRES_DB:-coves_dev}

     

       26
       26
       +
             POSTGRES_USER: ${POSTGRES_USER:-dev_user}

     

       27
       27
       +
             POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-dev_password}

     

       28
       28
       +
           volumes:

     

       29
       29
       +
             - postgres-data:/var/lib/postgresql/data

     

       30
       30
       +
           networks:

     

       31
       31
       +
             - coves-dev

     

       32
       32
       +
           healthcheck:

     

       33
       33
       +
             test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-dev_user} -d ${POSTGRES_DB:-coves_dev}"]

     

       34
       34
       +
             interval: 5s

     

       35
       35
       +
             timeout: 5s

     

       36
       36
       +
             retries: 5

     

       37
       37
       +
       

     

       38
       38
       +
         # PostgreSQL Test Database (Port 5434) - Optional

     

       39
       39
       +
         # Use with: docker-compose --profile test up postgres-test

     

       40
       40
       +
         postgres-test:

     

       41
       41
       +
           image: postgres:15

     

       42
       42
       +
           container_name: coves-test-postgres

     

       43
       43
       +
           ports:

     

       44
       44
       +
             - "5434:5432"

     

       45
       45
       +
           environment:

     

       46
       46
       +
             POSTGRES_DB: coves_test

     

       47
       47
       +
             POSTGRES_USER: test_user

     

       48
       48
       +
             POSTGRES_PASSWORD: test_password

     

       49
       49
       +
           volumes:

     

       50
       50
       +
             - postgres-test-data:/var/lib/postgresql/data

     

       51
       51
       +
           networks:

     

       52
       52
       +
             - coves-dev

     

       53
       53
       +
           healthcheck:

     

       54
       54
       +
             test: ["CMD-SHELL", "pg_isready -U test_user -d coves_test"]

     

       55
       55
       +
             interval: 5s

     

       56
       56
       +
             timeout: 5s

     

       57
       57
       +
             retries: 5

     

       58
       58
       +
           profiles:

     

       59
       59
       +
             - test

     

       60
       60
       +
       

     

       9
       61
        
         # Bluesky Personal Data Server (PDS)

     

       10
       62
        
         # Handles user repositories, DIDs, and CAR files

     

       11
       63
        
         pds:

     
···

       76
       128
        
             # IMPORTANT: Allow insecure WebSocket for local PDS (ws:// instead of wss://)

     

       77
       129
        
             BGS_CRAWL_INSECURE_WS: "true"

     

       78
       130
        
       

     

       79
       79
       -
             # Database connection (uses shared PostgreSQL for relay state)

     

       80
       80
       -
             DATABASE_URL: postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@host.docker.internal:${POSTGRES_PORT}/${POSTGRES_DB}?sslmode=disable

     

       131
       131
       +
             # Database connection (uses PostgreSQL for relay state)

     

       132
       132
       +
             DATABASE_URL: postgresql://${POSTGRES_USER:-dev_user}:${POSTGRES_PASSWORD:-dev_password}@postgres:5432/${POSTGRES_DB:-coves_dev}?sslmode=disable

     

       81
       133
        
       

     

       82
       134
        
             # Relay will discover PDSs automatically - use admin API to restrict!

     

       83
       135
        
             # See comments above for how to configure allowlist

     
···

       86
       138
        
             LOG_LEVEL: ${LOG_LEVEL:-debug}

     

       87
       139
        
           networks:

     

       88
       140
        
             - coves-dev

     

       89
       89
       -
           extra_hosts:

     

       90
       90
       -
             - "host.docker.internal:host-gateway"

     

       91
       141
        
           depends_on:

     

       142
       142
       +
             postgres:

     

       143
       143
       +
               condition: service_healthy

     

       92
       144
        
             pds:

     

       93
       145
        
               condition: service_healthy

     

       94
       146
        
           healthcheck:

     
···

       112
       164
        
         #     - "8081:8080"  # AppView API (avoiding conflicts)

     

       113
       165
        
         #   environment:

     

       114
       166
        
         #     # Database connection

     

       115
       115
       -
         #     DATABASE_URL: postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@host.docker.internal:${POSTGRES_PORT}/${POSTGRES_DB}?sslmode=disable

     

       167
       167
       +
         #     DATABASE_URL: postgresql://${POSTGRES_USER:-dev_user}:${POSTGRES_PASSWORD:-dev_password}@postgres:5432/${POSTGRES_DB:-coves_dev}?sslmode=disable

     

       116
       168
        
         #

     

       117
       169
        
         #     # PDS Firehose subscription (direct, no relay)

     

       118
       170
        
         #     FIREHOSE_URL: ws://pds:3000/xrpc/com.atproto.sync.subscribeRepos

     
···

       126
       178
        
         #     LOG_LEVEL: ${LOG_LEVEL:-debug}

     

       127
       179
        
         #   networks:

     

       128
       180
        
         #     - coves-dev

     

       129
       129
       -
         #   extra_hosts:

     

       130
       130
       -
         #     - "host.docker.internal:host-gateway"

     

       131
       181
        
         #   depends_on:

     

       132
       132
       -
         #     - pds

     

       133
       133
       -
       

     

       134
       134
       -
       # Note: PostgreSQL runs separately via internal/db/local_dev_db_compose/

     

       135
       135
       -
       # This stack connects to it via host.docker.internal:5433

     

       182
       182
       +
         #     postgres:

     

       183
       183
       +
         #       condition: service_healthy

     

       184
       184
       +
         #     pds:

     

       185
       185
       +
         #       condition: service_healthy

     

       136
       186
        
       

     

       137
       187
        
       networks:

     

       138
       188
        
         coves-dev:

     
···

       140
       190
        
           name: coves-dev-network

     

       141
       191
        
       

     

       142
       192
        
       volumes:

     

       193
       193
       +
         postgres-data:

     

       194
       194
       +
           name: coves-dev-postgres-data

     

       195
       195
       +
         postgres-test-data:

     

       196
       196
       +
           name: coves-test-postgres-data

     

       143
       197
        
         pds-data:

     

       144
       198
        
           name: coves-dev-pds-data

-469

internal/api/handlers/repository_handler.go

···

       1
       1
       -
       package handlers

     

       2
       2
       -
       

     

       3
       3
       -
       import (

     

       4
       4
       -
       	"encoding/json"

     

       5
       5
       -
       	"fmt"

     

       6
       6
       -
       	"io"

     

       7
       7
       -
       	"net/http"

     

       8
       8
       -
       	"strings"

     

       9
       9
       -
       

     

       10
       10
       -
       	"Coves/internal/core/repository"

     

       11
       11
       -
       	"github.com/ipfs/go-cid"

     

       12
       12
       -
       	cbornode "github.com/ipfs/go-ipld-cbor"

     

       13
       13
       -
       )

     

       14
       14
       -
       

     

       15
       15
       -
       // RepositoryHandler handles HTTP requests for repository operations

     

       16
       16
       -
       type RepositoryHandler struct {

     

       17
       17
       -
       	service repository.RepositoryService

     

       18
       18
       -
       }

     

       19
       19
       -
       

     

       20
       20
       -
       // NewRepositoryHandler creates a new repository handler

     

       21
       21
       -
       func NewRepositoryHandler(service repository.RepositoryService) *RepositoryHandler {

     

       22
       22
       -
       	return &RepositoryHandler{

     

       23
       23
       -
       		service: service,

     

       24
       24
       -
       	}

     

       25
       25
       -
       }

     

       26
       26
       -
       

     

       27
       27
       -
       // AT Protocol XRPC request/response types

     

       28
       28
       -
       

     

       29
       29
       -
       // CreateRecordRequest represents a request to create a record

     

       30
       30
       -
       type CreateRecordRequest struct {

     

       31
       31
       -
       	Repo       string          `json:"repo"`       // DID of the repository

     

       32
       32
       -
       	Collection string          `json:"collection"` // NSID of the collection

     

       33
       33
       -
       	RKey       string          `json:"rkey,omitempty"` // Optional record key

     

       34
       34
       -
       	Validate   bool            `json:"validate"`   // Whether to validate against lexicon

     

       35
       35
       -
       	Record     json.RawMessage `json:"record"`     // The record data

     

       36
       36
       -
       }

     

       37
       37
       -
       

     

       38
       38
       -
       // CreateRecordResponse represents the response after creating a record

     

       39
       39
       -
       type CreateRecordResponse struct {

     

       40
       40
       -
       	URI string `json:"uri"` // AT-URI of the created record

     

       41
       41
       -
       	CID string `json:"cid"` // CID of the record

     

       42
       42
       -
       }

     

       43
       43
       -
       

     

       44
       44
       -
       // GetRecordRequest represents a request to get a record

     

       45
       45
       -
       type GetRecordRequest struct {

     

       46
       46
       -
       	Repo       string `json:"repo"`       // DID of the repository

     

       47
       47
       -
       	Collection string `json:"collection"` // NSID of the collection

     

       48
       48
       -
       	RKey       string `json:"rkey"`       // Record key

     

       49
       49
       -
       }

     

       50
       50
       -
       

     

       51
       51
       -
       // GetRecordResponse represents the response when getting a record

     

       52
       52
       -
       type GetRecordResponse struct {

     

       53
       53
       -
       	URI   string          `json:"uri"`   // AT-URI of the record

     

       54
       54
       -
       	CID   string          `json:"cid"`   // CID of the record

     

       55
       55
       -
       	Value json.RawMessage `json:"value"` // The record data

     

       56
       56
       -
       }

     

       57
       57
       -
       

     

       58
       58
       -
       // PutRecordRequest represents a request to update a record

     

       59
       59
       -
       type PutRecordRequest struct {

     

       60
       60
       -
       	Repo       string          `json:"repo"`       // DID of the repository

     

       61
       61
       -
       	Collection string          `json:"collection"` // NSID of the collection

     

       62
       62
       -
       	RKey       string          `json:"rkey"`       // Record key

     

       63
       63
       -
       	Validate   bool            `json:"validate"`   // Whether to validate against lexicon

     

       64
       64
       -
       	Record     json.RawMessage `json:"record"`     // The record data

     

       65
       65
       -
       }

     

       66
       66
       -
       

     

       67
       67
       -
       // PutRecordResponse represents the response after updating a record

     

       68
       68
       -
       type PutRecordResponse struct {

     

       69
       69
       -
       	URI string `json:"uri"` // AT-URI of the updated record

     

       70
       70
       -
       	CID string `json:"cid"` // CID of the record

     

       71
       71
       -
       }

     

       72
       72
       -
       

     

       73
       73
       -
       // DeleteRecordRequest represents a request to delete a record

     

       74
       74
       -
       type DeleteRecordRequest struct {

     

       75
       75
       -
       	Repo       string `json:"repo"`       // DID of the repository

     

       76
       76
       -
       	Collection string `json:"collection"` // NSID of the collection

     

       77
       77
       -
       	RKey       string `json:"rkey"`       // Record key

     

       78
       78
       -
       }

     

       79
       79
       -
       

     

       80
       80
       -
       // ListRecordsRequest represents a request to list records

     

       81
       81
       -
       type ListRecordsRequest struct {

     

       82
       82
       -
       	Repo       string `json:"repo"`       // DID of the repository

     

       83
       83
       -
       	Collection string `json:"collection"` // NSID of the collection

     

       84
       84
       -
       	Limit      int    `json:"limit,omitempty"`

     

       85
       85
       -
       	Cursor     string `json:"cursor,omitempty"`

     

       86
       86
       -
       }

     

       87
       87
       -
       

     

       88
       88
       -
       // ListRecordsResponse represents the response when listing records

     

       89
       89
       -
       type ListRecordsResponse struct {

     

       90
       90
       -
       	Cursor  string         `json:"cursor,omitempty"`

     

       91
       91
       -
       	Records []RecordOutput `json:"records"`

     

       92
       92
       -
       }

     

       93
       93
       -
       

     

       94
       94
       -
       // RecordOutput represents a record in list responses

     

       95
       95
       -
       type RecordOutput struct {

     

       96
       96
       -
       	URI   string          `json:"uri"`

     

       97
       97
       -
       	CID   string          `json:"cid"`

     

       98
       98
       -
       	Value json.RawMessage `json:"value"`

     

       99
       99
       -
       }

     

       100
       100
       -
       

     

       101
       101
       -
       // Handler methods

     

       102
       102
       -
       

     

       103
       103
       -
       // CreateRecord handles POST /xrpc/com.atproto.repo.createRecord

     

       104
       104
       -
       func (h *RepositoryHandler) CreateRecord(w http.ResponseWriter, r *http.Request) {

     

       105
       105
       -
       	var req CreateRecordRequest

     

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

     

       107
       107
       -
       		writeError(w, http.StatusBadRequest, fmt.Sprintf("invalid request: %v", err))

     

       108
       108
       -
       		return

     

       109
       109
       -
       	}

     

       110
       110
       -
       

     

       111
       111
       -
       	// Validate required fields

     

       112
       112
       -
       	if req.Repo == "" || req.Collection == "" || len(req.Record) == 0 {

     

       113
       113
       -
       		writeError(w, http.StatusBadRequest, "missing required fields")

     

       114
       114
       -
       		return

     

       115
       115
       -
       	}

     

       116
       116
       -
       

     

       117
       117
       -
       	// Create a generic record structure for CBOR encoding

     

       118
       118
       -
       	// In a real implementation, you would unmarshal to the specific lexicon type

     

       119
       119
       -
       	recordData := &GenericRecord{

     

       120
       120
       -
       		Data: req.Record,

     

       121
       121
       -
       	}

     

       122
       122
       -
       

     

       123
       123
       -
       	input := repository.CreateRecordInput{

     

       124
       124
       -
       		DID:        req.Repo,

     

       125
       125
       -
       		Collection: req.Collection,

     

       126
       126
       -
       		RecordKey:  req.RKey,

     

       127
       127
       -
       		Record:     recordData,

     

       128
       128
       -
       		Validate:   req.Validate,

     

       129
       129
       -
       	}

     

       130
       130
       -
       

     

       131
       131
       -
       	record, err := h.service.CreateRecord(input)

     

       132
       132
       -
       	if err != nil {

     

       133
       133
       -
       		writeError(w, http.StatusInternalServerError, fmt.Sprintf("failed to create record: %v", err))

     

       134
       134
       -
       		return

     

       135
       135
       -
       	}

     

       136
       136
       -
       

     

       137
       137
       -
       	resp := CreateRecordResponse{

     

       138
       138
       -
       		URI: record.URI,

     

       139
       139
       -
       		CID: record.CID.String(),

     

       140
       140
       -
       	}

     

       141
       141
       -
       

     

       142
       142
       -
       	writeJSON(w, http.StatusOK, resp)

     

       143
       143
       -
       }

     

       144
       144
       -
       

     

       145
       145
       -
       // GetRecord handles GET /xrpc/com.atproto.repo.getRecord

     

       146
       146
       -
       func (h *RepositoryHandler) GetRecord(w http.ResponseWriter, r *http.Request) {

     

       147
       147
       -
       	// Parse query parameters

     

       148
       148
       -
       	repo := r.URL.Query().Get("repo")

     

       149
       149
       -
       	collection := r.URL.Query().Get("collection")

     

       150
       150
       -
       	rkey := r.URL.Query().Get("rkey")

     

       151
       151
       -
       

     

       152
       152
       -
       	if repo == "" || collection == "" || rkey == "" {

     

       153
       153
       -
       		writeError(w, http.StatusBadRequest, "missing required parameters")

     

       154
       154
       -
       		return

     

       155
       155
       -
       	}

     

       156
       156
       -
       

     

       157
       157
       -
       	input := repository.GetRecordInput{

     

       158
       158
       -
       		DID:        repo,

     

       159
       159
       -
       		Collection: collection,

     

       160
       160
       -
       		RecordKey:  rkey,

     

       161
       161
       -
       	}

     

       162
       162
       -
       

     

       163
       163
       -
       	record, err := h.service.GetRecord(input)

     

       164
       164
       -
       	if err != nil {

     

       165
       165
       -
       		if strings.Contains(err.Error(), "not found") {

     

       166
       166
       -
       			writeError(w, http.StatusNotFound, "record not found")

     

       167
       167
       -
       			return

     

       168
       168
       -
       		}

     

       169
       169
       -
       		writeError(w, http.StatusInternalServerError, fmt.Sprintf("failed to get record: %v", err))

     

       170
       170
       -
       		return

     

       171
       171
       -
       	}

     

       172
       172
       -
       

     

       173
       173
       -
       	resp := GetRecordResponse{

     

       174
       174
       -
       		URI:   record.URI,

     

       175
       175
       -
       		CID:   record.CID.String(),

     

       176
       176
       -
       		Value: json.RawMessage(record.Value),

     

       177
       177
       -
       	}

     

       178
       178
       -
       

     

       179
       179
       -
       	writeJSON(w, http.StatusOK, resp)

     

       180
       180
       -
       }

     

       181
       181
       -
       

     

       182
       182
       -
       // PutRecord handles POST /xrpc/com.atproto.repo.putRecord

     

       183
       183
       -
       func (h *RepositoryHandler) PutRecord(w http.ResponseWriter, r *http.Request) {

     

       184
       184
       -
       	var req PutRecordRequest

     

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

     

       186
       186
       -
       		writeError(w, http.StatusBadRequest, fmt.Sprintf("invalid request: %v", err))

     

       187
       187
       -
       		return

     

       188
       188
       -
       	}

     

       189
       189
       -
       

     

       190
       190
       -
       	// Validate required fields

     

       191
       191
       -
       	if req.Repo == "" || req.Collection == "" || req.RKey == "" || len(req.Record) == 0 {

     

       192
       192
       -
       		writeError(w, http.StatusBadRequest, "missing required fields")

     

       193
       193
       -
       		return

     

       194
       194
       -
       	}

     

       195
       195
       -
       

     

       196
       196
       -
       	// Create a generic record structure for CBOR encoding

     

       197
       197
       -
       	recordData := &GenericRecord{

     

       198
       198
       -
       		Data: req.Record,

     

       199
       199
       -
       	}

     

       200
       200
       -
       

     

       201
       201
       -
       	input := repository.UpdateRecordInput{

     

       202
       202
       -
       		DID:        req.Repo,

     

       203
       203
       -
       		Collection: req.Collection,

     

       204
       204
       -
       		RecordKey:  req.RKey,

     

       205
       205
       -
       		Record:     recordData,

     

       206
       206
       -
       		Validate:   req.Validate,

     

       207
       207
       -
       	}

     

       208
       208
       -
       

     

       209
       209
       -
       	record, err := h.service.UpdateRecord(input)

     

       210
       210
       -
       	if err != nil {

     

       211
       211
       -
       		if strings.Contains(err.Error(), "not found") {

     

       212
       212
       -
       			writeError(w, http.StatusNotFound, "record not found")

     

       213
       213
       -
       			return

     

       214
       214
       -
       		}

     

       215
       215
       -
       		writeError(w, http.StatusInternalServerError, fmt.Sprintf("failed to update record: %v", err))

     

       216
       216
       -
       		return

     

       217
       217
       -
       	}

     

       218
       218
       -
       

     

       219
       219
       -
       	resp := PutRecordResponse{

     

       220
       220
       -
       		URI: record.URI,

     

       221
       221
       -
       		CID: record.CID.String(),

     

       222
       222
       -
       	}

     

       223
       223
       -
       

     

       224
       224
       -
       	writeJSON(w, http.StatusOK, resp)

     

       225
       225
       -
       }

     

       226
       226
       -
       

     

       227
       227
       -
       // DeleteRecord handles POST /xrpc/com.atproto.repo.deleteRecord

     

       228
       228
       -
       func (h *RepositoryHandler) DeleteRecord(w http.ResponseWriter, r *http.Request) {

     

       229
       229
       -
       	var req DeleteRecordRequest

     

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

     

       231
       231
       -
       		writeError(w, http.StatusBadRequest, fmt.Sprintf("invalid request: %v", err))

     

       232
       232
       -
       		return

     

       233
       233
       -
       	}

     

       234
       234
       -
       

     

       235
       235
       -
       	// Validate required fields

     

       236
       236
       -
       	if req.Repo == "" || req.Collection == "" || req.RKey == "" {

     

       237
       237
       -
       		writeError(w, http.StatusBadRequest, "missing required fields")

     

       238
       238
       -
       		return

     

       239
       239
       -
       	}

     

       240
       240
       -
       

     

       241
       241
       -
       	input := repository.DeleteRecordInput{

     

       242
       242
       -
       		DID:        req.Repo,

     

       243
       243
       -
       		Collection: req.Collection,

     

       244
       244
       -
       		RecordKey:  req.RKey,

     

       245
       245
       -
       	}

     

       246
       246
       -
       

     

       247
       247
       -
       	err := h.service.DeleteRecord(input)

     

       248
       248
       -
       	if err != nil {

     

       249
       249
       -
       		if strings.Contains(err.Error(), "not found") {

     

       250
       250
       -
       			writeError(w, http.StatusNotFound, "record not found")

     

       251
       251
       -
       			return

     

       252
       252
       -
       		}

     

       253
       253
       -
       		writeError(w, http.StatusInternalServerError, fmt.Sprintf("failed to delete record: %v", err))

     

       254
       254
       -
       		return

     

       255
       255
       -
       	}

     

       256
       256
       -
       

     

       257
       257
       -
       	w.WriteHeader(http.StatusOK)

     

       258
       258
       -
       	w.Write([]byte("{}"))

     

       259
       259
       -
       }

     

       260
       260
       -
       

     

       261
       261
       -
       // ListRecords handles GET /xrpc/com.atproto.repo.listRecords

     

       262
       262
       -
       func (h *RepositoryHandler) ListRecords(w http.ResponseWriter, r *http.Request) {

     

       263
       263
       -
       	// Parse query parameters

     

       264
       264
       -
       	repo := r.URL.Query().Get("repo")

     

       265
       265
       -
       	collection := r.URL.Query().Get("collection")

     

       266
       266
       -
       	limit := 50 // Default limit

     

       267
       267
       -
       	cursor := r.URL.Query().Get("cursor")

     

       268
       268
       -
       

     

       269
       269
       -
       	if repo == "" || collection == "" {

     

       270
       270
       -
       		writeError(w, http.StatusBadRequest, "missing required parameters")

     

       271
       271
       -
       		return

     

       272
       272
       -
       	}

     

       273
       273
       -
       

     

       274
       274
       -
       	// Parse limit if provided

     

       275
       275
       -
       	if limitStr := r.URL.Query().Get("limit"); limitStr != "" {

     

       276
       276
       -
       		fmt.Sscanf(limitStr, "%d", &limit)

     

       277
       277
       -
       		if limit > 100 {

     

       278
       278
       -
       			limit = 100 // Max limit

     

       279
       279
       -
       		}

     

       280
       280
       -
       	}

     

       281
       281
       -
       

     

       282
       282
       -
       	records, nextCursor, err := h.service.ListRecords(repo, collection, limit, cursor)

     

       283
       283
       -
       	if err != nil {

     

       284
       284
       -
       		writeError(w, http.StatusInternalServerError, fmt.Sprintf("failed to list records: %v", err))

     

       285
       285
       -
       		return

     

       286
       286
       -
       	}

     

       287
       287
       -
       

     

       288
       288
       -
       	// Convert to output format

     

       289
       289
       -
       	recordOutputs := make([]RecordOutput, len(records))

     

       290
       290
       -
       	for i, record := range records {

     

       291
       291
       -
       		recordOutputs[i] = RecordOutput{

     

       292
       292
       -
       			URI:   record.URI,

     

       293
       293
       -
       			CID:   record.CID.String(),

     

       294
       294
       -
       			Value: json.RawMessage(record.Value),

     

       295
       295
       -
       		}

     

       296
       296
       -
       	}

     

       297
       297
       -
       

     

       298
       298
       -
       	resp := ListRecordsResponse{

     

       299
       299
       -
       		Cursor:  nextCursor,

     

       300
       300
       -
       		Records: recordOutputs,

     

       301
       301
       -
       	}

     

       302
       302
       -
       

     

       303
       303
       -
       	writeJSON(w, http.StatusOK, resp)

     

       304
       304
       -
       }

     

       305
       305
       -
       

     

       306
       306
       -
       // GetRepo handles GET /xrpc/com.atproto.sync.getRepo

     

       307
       307
       -
       func (h *RepositoryHandler) GetRepo(w http.ResponseWriter, r *http.Request) {

     

       308
       308
       -
       	// Parse query parameters

     

       309
       309
       -
       	did := r.URL.Query().Get("did")

     

       310
       310
       -
       	if did == "" {

     

       311
       311
       -
       		writeError(w, http.StatusBadRequest, "missing did parameter")

     

       312
       312
       -
       		return

     

       313
       313
       -
       	}

     

       314
       314
       -
       

     

       315
       315
       -
       	// Export repository as CAR file

     

       316
       316
       -
       	carData, err := h.service.ExportRepository(did)

     

       317
       317
       -
       	if err != nil {

     

       318
       318
       -
       		if strings.Contains(err.Error(), "not found") {

     

       319
       319
       -
       			writeError(w, http.StatusNotFound, "repository not found")

     

       320
       320
       -
       			return

     

       321
       321
       -
       		}

     

       322
       322
       -
       		writeError(w, http.StatusInternalServerError, fmt.Sprintf("failed to export repository: %v", err))

     

       323
       323
       -
       		return

     

       324
       324
       -
       	}

     

       325
       325
       -
       

     

       326
       326
       -
       	// Set appropriate headers for CAR file

     

       327
       327
       -
       	w.Header().Set("Content-Type", "application/vnd.ipld.car")

     

       328
       328
       -
       	w.Header().Set("Content-Length", fmt.Sprintf("%d", len(carData)))

     

       329
       329
       -
       	w.WriteHeader(http.StatusOK)

     

       330
       330
       -
       	w.Write(carData)

     

       331
       331
       -
       }

     

       332
       332
       -
       

     

       333
       333
       -
       // Additional repository management endpoints

     

       334
       334
       -
       

     

       335
       335
       -
       // CreateRepository handles POST /xrpc/com.atproto.repo.createRepo

     

       336
       336
       -
       func (h *RepositoryHandler) CreateRepository(w http.ResponseWriter, r *http.Request) {

     

       337
       337
       -
       	var req struct {

     

       338
       338
       -
       		DID string `json:"did"`

     

       339
       339
       -
       	}

     

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

     

       341
       341
       -
       		writeError(w, http.StatusBadRequest, fmt.Sprintf("invalid request: %v", err))

     

       342
       342
       -
       		return

     

       343
       343
       -
       	}

     

       344
       344
       -
       

     

       345
       345
       -
       	if req.DID == "" {

     

       346
       346
       -
       		writeError(w, http.StatusBadRequest, "missing did")

     

       347
       347
       -
       		return

     

       348
       348
       -
       	}

     

       349
       349
       -
       

     

       350
       350
       -
       	repo, err := h.service.CreateRepository(req.DID)

     

       351
       351
       -
       	if err != nil {

     

       352
       352
       -
       		if strings.Contains(err.Error(), "already exists") {

     

       353
       353
       -
       			writeError(w, http.StatusConflict, "repository already exists")

     

       354
       354
       -
       			return

     

       355
       355
       -
       		}

     

       356
       356
       -
       		writeError(w, http.StatusInternalServerError, fmt.Sprintf("failed to create repository: %v", err))

     

       357
       357
       -
       		return

     

       358
       358
       -
       	}

     

       359
       359
       -
       

     

       360
       360
       -
       	resp := struct {

     

       361
       361
       -
       		DID     string `json:"did"`

     

       362
       362
       -
       		HeadCID string `json:"head"`

     

       363
       363
       -
       	}{

     

       364
       364
       -
       		DID:     repo.DID,

     

       365
       365
       -
       		HeadCID: repo.HeadCID.String(),

     

       366
       366
       -
       	}

     

       367
       367
       -
       

     

       368
       368
       -
       	writeJSON(w, http.StatusOK, resp)

     

       369
       369
       -
       }

     

       370
       370
       -
       

     

       371
       371
       -
       // GetCommit handles GET /xrpc/com.atproto.sync.getCommit

     

       372
       372
       -
       func (h *RepositoryHandler) GetCommit(w http.ResponseWriter, r *http.Request) {

     

       373
       373
       -
       	// Parse query parameters

     

       374
       374
       -
       	did := r.URL.Query().Get("did")

     

       375
       375
       -
       	commitCIDStr := r.URL.Query().Get("cid")

     

       376
       376
       -
       

     

       377
       377
       -
       	if did == "" || commitCIDStr == "" {

     

       378
       378
       -
       		writeError(w, http.StatusBadRequest, "missing required parameters")

     

       379
       379
       -
       		return

     

       380
       380
       -
       	}

     

       381
       381
       -
       

     

       382
       382
       -
       	// Parse CID

     

       383
       383
       -
       	commitCID, err := cid.Parse(commitCIDStr)

     

       384
       384
       -
       	if err != nil {

     

       385
       385
       -
       		writeError(w, http.StatusBadRequest, "invalid cid")

     

       386
       386
       -
       		return

     

       387
       387
       -
       	}

     

       388
       388
       -
       

     

       389
       389
       -
       	commit, err := h.service.GetCommit(did, commitCID)

     

       390
       390
       -
       	if err != nil {

     

       391
       391
       -
       		if strings.Contains(err.Error(), "not found") {

     

       392
       392
       -
       			writeError(w, http.StatusNotFound, "commit not found")

     

       393
       393
       -
       			return

     

       394
       394
       -
       		}

     

       395
       395
       -
       		writeError(w, http.StatusInternalServerError, fmt.Sprintf("failed to get commit: %v", err))

     

       396
       396
       -
       		return

     

       397
       397
       -
       	}

     

       398
       398
       -
       

     

       399
       399
       -
       	resp := struct {

     

       400
       400
       -
       		CID       string  `json:"cid"`

     

       401
       401
       -
       		DID       string  `json:"did"`

     

       402
       402
       -
       		Version   int     `json:"version"`

     

       403
       403
       -
       		PrevCID   *string `json:"prev,omitempty"`

     

       404
       404
       -
       		DataCID   string  `json:"data"`

     

       405
       405
       -
       		Revision  string  `json:"rev"`

     

       406
       406
       -
       		Signature string  `json:"sig"`

     

       407
       407
       -
       		CreatedAt string  `json:"createdAt"`

     

       408
       408
       -
       	}{

     

       409
       409
       -
       		CID:       commit.CID.String(),

     

       410
       410
       -
       		DID:       commit.DID,

     

       411
       411
       -
       		Version:   commit.Version,

     

       412
       412
       -
       		DataCID:   commit.DataCID.String(),

     

       413
       413
       -
       		Revision:  commit.Revision,

     

       414
       414
       -
       		Signature: fmt.Sprintf("%x", commit.Signature),

     

       415
       415
       -
       		CreatedAt: commit.CreatedAt.Format("2006-01-02T15:04:05Z"),

     

       416
       416
       -
       	}

     

       417
       417
       -
       

     

       418
       418
       -
       	if commit.PrevCID != nil {

     

       419
       419
       -
       		prev := commit.PrevCID.String()

     

       420
       420
       -
       		resp.PrevCID = &prev

     

       421
       421
       -
       	}

     

       422
       422
       -
       

     

       423
       423
       -
       	writeJSON(w, http.StatusOK, resp)

     

       424
       424
       -
       }

     

       425
       425
       -
       

     

       426
       426
       -
       // Helper functions

     

       427
       427
       -
       

     

       428
       428
       -
       func writeJSON(w http.ResponseWriter, status int, data interface{}) {

     

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

     

       430
       430
       -
       	w.WriteHeader(status)

     

       431
       431
       -
       	json.NewEncoder(w).Encode(data)

     

       432
       432
       -
       }

     

       433
       433
       -
       

     

       434
       434
       -
       func writeError(w http.ResponseWriter, status int, message string) {

     

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

     

       436
       436
       -
       	w.WriteHeader(status)

     

       437
       437
       -
       	json.NewEncoder(w).Encode(map[string]interface{}{

     

       438
       438
       -
       		"error":   http.StatusText(status),

     

       439
       439
       -
       		"message": message,

     

       440
       440
       -
       	})

     

       441
       441
       -
       }

     

       442
       442
       -
       

     

       443
       443
       -
       // GenericRecord is a temporary structure for CBOR encoding

     

       444
       444
       -
       // In a real implementation, you would have specific types for each lexicon

     

       445
       445
       -
       type GenericRecord struct {

     

       446
       446
       -
       	Data json.RawMessage

     

       447
       447
       -
       }

     

       448
       448
       -
       

     

       449
       449
       -
       // MarshalCBOR implements the CBORMarshaler interface

     

       450
       450
       -
       func (g *GenericRecord) MarshalCBOR(w io.Writer) error {

     

       451
       451
       -
       	// Parse JSON data into a generic map for proper CBOR encoding

     

       452
       452
       -
       	var data map[string]interface{}

     

       453
       453
       -
       	if err := json.Unmarshal(g.Data, &data); err != nil {

     

       454
       454
       -
       		return fmt.Errorf("failed to unmarshal JSON data: %w", err)

     

       455
       455
       -
       	}

     

       456
       456
       -
       	

     

       457
       457
       -
       	// Use IPFS CBOR encoding to properly encode the data

     

       458
       458
       -
       	cborData, err := cbornode.DumpObject(data)

     

       459
       459
       -
       	if err != nil {

     

       460
       460
       -
       		return fmt.Errorf("failed to marshal as CBOR: %w", err)

     

       461
       461
       -
       	}

     

       462
       462
       -
       	

     

       463
       463
       -
       	_, err = w.Write(cborData)

     

       464
       464
       -
       	if err != nil {

     

       465
       465
       -
       		return fmt.Errorf("failed to write CBOR data: %w", err)

     

       466
       466
       -
       	}

     

       467
       467
       -
       	

     

       468
       468
       -
       	return nil

     

       469
       469
       -
       }

-191

internal/api/handlers/repository_handler_test.go

···

       1
       1
       -
       package handlers

     

       2
       2
       -
       

     

       3
       3
       -
       import (

     

       4
       4
       -
       	"bytes"

     

       5
       5
       -
       	"encoding/json"

     

       6
       6
       -
       	"net/http"

     

       7
       7
       -
       	"net/http/httptest"

     

       8
       8
       -
       	"testing"

     

       9
       9
       -
       

     

       10
       10
       -
       	"Coves/internal/core/repository"

     

       11
       11
       -
       	"github.com/ipfs/go-cid"

     

       12
       12
       -
       )

     

       13
       13
       -
       

     

       14
       14
       -
       // MockRepositoryService is a mock implementation for testing

     

       15
       15
       -
       type MockRepositoryService struct {

     

       16
       16
       -
       	repositories map[string]*repository.Repository

     

       17
       17
       -
       	records      map[string]*repository.Record

     

       18
       18
       -
       }

     

       19
       19
       -
       

     

       20
       20
       -
       func NewMockRepositoryService() *MockRepositoryService {

     

       21
       21
       -
       	return &MockRepositoryService{

     

       22
       22
       -
       		repositories: make(map[string]*repository.Repository),

     

       23
       23
       -
       		records:      make(map[string]*repository.Record),

     

       24
       24
       -
       	}

     

       25
       25
       -
       }

     

       26
       26
       -
       

     

       27
       27
       -
       func (m *MockRepositoryService) CreateRepository(did string) (*repository.Repository, error) {

     

       28
       28
       -
       	repo := &repository.Repository{

     

       29
       29
       -
       		DID:     did,

     

       30
       30
       -
       		HeadCID: cid.Undef,

     

       31
       31
       -
       	}

     

       32
       32
       -
       	m.repositories[did] = repo

     

       33
       33
       -
       	return repo, nil

     

       34
       34
       -
       }

     

       35
       35
       -
       

     

       36
       36
       -
       func (m *MockRepositoryService) GetRepository(did string) (*repository.Repository, error) {

     

       37
       37
       -
       	repo, exists := m.repositories[did]

     

       38
       38
       -
       	if !exists {

     

       39
       39
       -
       		return nil, nil

     

       40
       40
       -
       	}

     

       41
       41
       -
       	return repo, nil

     

       42
       42
       -
       }

     

       43
       43
       -
       

     

       44
       44
       -
       func (m *MockRepositoryService) DeleteRepository(did string) error {

     

       45
       45
       -
       	delete(m.repositories, did)

     

       46
       46
       -
       	return nil

     

       47
       47
       -
       }

     

       48
       48
       -
       

     

       49
       49
       -
       func (m *MockRepositoryService) CreateRecord(input repository.CreateRecordInput) (*repository.Record, error) {

     

       50
       50
       -
       	uri := "at://" + input.DID + "/" + input.Collection + "/" + input.RecordKey

     

       51
       51
       -
       	record := &repository.Record{

     

       52
       52
       -
       		URI:        uri,

     

       53
       53
       -
       		CID:        cid.Undef,

     

       54
       54
       -
       		Collection: input.Collection,

     

       55
       55
       -
       		RecordKey:  input.RecordKey,

     

       56
       56
       -
       		Value:      []byte(`{"test": "data"}`),

     

       57
       57
       -
       	}

     

       58
       58
       -
       	m.records[uri] = record

     

       59
       59
       -
       	return record, nil

     

       60
       60
       -
       }

     

       61
       61
       -
       

     

       62
       62
       -
       func (m *MockRepositoryService) GetRecord(input repository.GetRecordInput) (*repository.Record, error) {

     

       63
       63
       -
       	uri := "at://" + input.DID + "/" + input.Collection + "/" + input.RecordKey

     

       64
       64
       -
       	record, exists := m.records[uri]

     

       65
       65
       -
       	if !exists {

     

       66
       66
       -
       		return nil, nil

     

       67
       67
       -
       	}

     

       68
       68
       -
       	return record, nil

     

       69
       69
       -
       }

     

       70
       70
       -
       

     

       71
       71
       -
       func (m *MockRepositoryService) UpdateRecord(input repository.UpdateRecordInput) (*repository.Record, error) {

     

       72
       72
       -
       	uri := "at://" + input.DID + "/" + input.Collection + "/" + input.RecordKey

     

       73
       73
       -
       	record := &repository.Record{

     

       74
       74
       -
       		URI:        uri,

     

       75
       75
       -
       		CID:        cid.Undef,

     

       76
       76
       -
       		Collection: input.Collection,

     

       77
       77
       -
       		RecordKey:  input.RecordKey,

     

       78
       78
       -
       		Value:      []byte(`{"test": "updated"}`),

     

       79
       79
       -
       	}

     

       80
       80
       -
       	m.records[uri] = record

     

       81
       81
       -
       	return record, nil

     

       82
       82
       -
       }

     

       83
       83
       -
       

     

       84
       84
       -
       func (m *MockRepositoryService) DeleteRecord(input repository.DeleteRecordInput) error {

     

       85
       85
       -
       	uri := "at://" + input.DID + "/" + input.Collection + "/" + input.RecordKey

     

       86
       86
       -
       	delete(m.records, uri)

     

       87
       87
       -
       	return nil

     

       88
       88
       -
       }

     

       89
       89
       -
       

     

       90
       90
       -
       func (m *MockRepositoryService) ListRecords(did string, collection string, limit int, cursor string) ([]*repository.Record, string, error) {

     

       91
       91
       -
       	var records []*repository.Record

     

       92
       92
       -
       	for _, record := range m.records {

     

       93
       93
       -
       		if record.Collection == collection {

     

       94
       94
       -
       			records = append(records, record)

     

       95
       95
       -
       		}

     

       96
       96
       -
       	}

     

       97
       97
       -
       	return records, "", nil

     

       98
       98
       -
       }

     

       99
       99
       -
       

     

       100
       100
       -
       func (m *MockRepositoryService) GetCommit(did string, cid cid.Cid) (*repository.Commit, error) {

     

       101
       101
       -
       	return nil, nil

     

       102
       102
       -
       }

     

       103
       103
       -
       

     

       104
       104
       -
       func (m *MockRepositoryService) ListCommits(did string, limit int, cursor string) ([]*repository.Commit, string, error) {

     

       105
       105
       -
       	return []*repository.Commit{}, "", nil

     

       106
       106
       -
       }

     

       107
       107
       -
       

     

       108
       108
       -
       func (m *MockRepositoryService) ExportRepository(did string) ([]byte, error) {

     

       109
       109
       -
       	return []byte("mock-car-data"), nil

     

       110
       110
       -
       }

     

       111
       111
       -
       

     

       112
       112
       -
       func (m *MockRepositoryService) ImportRepository(did string, carData []byte) error {

     

       113
       113
       -
       	return nil

     

       114
       114
       -
       }

     

       115
       115
       -
       

     

       116
       116
       -
       func TestCreateRecordHandler(t *testing.T) {

     

       117
       117
       -
       	mockService := NewMockRepositoryService()

     

       118
       118
       -
       	handler := NewRepositoryHandler(mockService)

     

       119
       119
       -
       

     

       120
       120
       -
       	// Create test request

     

       121
       121
       -
       	reqData := CreateRecordRequest{

     

       122
       122
       -
       		Repo:       "did:plc:test123",

     

       123
       123
       -
       		Collection: "app.bsky.feed.post",

     

       124
       124
       -
       		RKey:       "testkey",

     

       125
       125
       -
       		Record:     json.RawMessage(`{"text": "Hello, world!"}`),

     

       126
       126
       -
       	}

     

       127
       127
       -
       

     

       128
       128
       -
       	reqBody, err := json.Marshal(reqData)

     

       129
       129
       -
       	if err != nil {

     

       130
       130
       -
       		t.Fatalf("Failed to marshal request: %v", err)

     

       131
       131
       -
       	}

     

       132
       132
       -
       

     

       133
       133
       -
       	req := httptest.NewRequest("POST", "/xrpc/com.atproto.repo.createRecord", bytes.NewReader(reqBody))

     

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

     

       135
       135
       -
       	w := httptest.NewRecorder()

     

       136
       136
       -
       

     

       137
       137
       -
       	// Call handler

     

       138
       138
       -
       	handler.CreateRecord(w, req)

     

       139
       139
       -
       

     

       140
       140
       -
       	// Check response

     

       141
       141
       -
       	if w.Code != http.StatusOK {

     

       142
       142
       -
       		t.Errorf("Expected status 200, got %d", w.Code)

     

       143
       143
       -
       	}

     

       144
       144
       -
       

     

       145
       145
       -
       	var resp CreateRecordResponse

     

       146
       146
       -
       	if err := json.NewDecoder(w.Body).Decode(&resp); err != nil {

     

       147
       147
       -
       		t.Fatalf("Failed to decode response: %v", err)

     

       148
       148
       -
       	}

     

       149
       149
       -
       

     

       150
       150
       -
       	expectedURI := "at://did:plc:test123/app.bsky.feed.post/testkey"

     

       151
       151
       -
       	if resp.URI != expectedURI {

     

       152
       152
       -
       		t.Errorf("Expected URI %s, got %s", expectedURI, resp.URI)

     

       153
       153
       -
       	}

     

       154
       154
       -
       }

     

       155
       155
       -
       

     

       156
       156
       -
       func TestGetRecordHandler(t *testing.T) {

     

       157
       157
       -
       	mockService := NewMockRepositoryService()

     

       158
       158
       -
       	handler := NewRepositoryHandler(mockService)

     

       159
       159
       -
       

     

       160
       160
       -
       	// Create a test record first

     

       161
       161
       -
       	uri := "at://did:plc:test123/app.bsky.feed.post/testkey"

     

       162
       162
       -
       	testRecord := &repository.Record{

     

       163
       163
       -
       		URI:        uri,

     

       164
       164
       -
       		CID:        cid.Undef,

     

       165
       165
       -
       		Collection: "app.bsky.feed.post",

     

       166
       166
       -
       		RecordKey:  "testkey",

     

       167
       167
       -
       		Value:      []byte(`{"text": "Hello, world!"}`),

     

       168
       168
       -
       	}

     

       169
       169
       -
       	mockService.records[uri] = testRecord

     

       170
       170
       -
       

     

       171
       171
       -
       	// Create test request

     

       172
       172
       -
       	req := httptest.NewRequest("GET", "/xrpc/com.atproto.repo.getRecord?repo=did:plc:test123&collection=app.bsky.feed.post&rkey=testkey", nil)

     

       173
       173
       -
       	w := httptest.NewRecorder()

     

       174
       174
       -
       

     

       175
       175
       -
       	// Call handler

     

       176
       176
       -
       	handler.GetRecord(w, req)

     

       177
       177
       -
       

     

       178
       178
       -
       	// Check response

     

       179
       179
       -
       	if w.Code != http.StatusOK {

     

       180
       180
       -
       		t.Errorf("Expected status 200, got %d", w.Code)

     

       181
       181
       -
       	}

     

       182
       182
       -
       

     

       183
       183
       -
       	var resp GetRecordResponse

     

       184
       184
       -
       	if err := json.NewDecoder(w.Body).Decode(&resp); err != nil {

     

       185
       185
       -
       		t.Fatalf("Failed to decode response: %v", err)

     

       186
       186
       -
       	}

     

       187
       187
       -
       

     

       188
       188
       -
       	if resp.URI != uri {

     

       189
       189
       -
       		t.Errorf("Expected URI %s, got %s", uri, resp.URI)

     

       190
       190
       -
       	}

     

       191
       191
       -
       }

-33

internal/api/routes/repository.go

···

       1
       1
       -
       package routes

     

       2
       2
       -
       

     

       3
       3
       -
       import (

     

       4
       4
       -
       	"Coves/internal/api/handlers"

     

       5
       5
       -
       	"Coves/internal/core/repository"

     

       6
       6
       -
       	"github.com/go-chi/chi/v5"

     

       7
       7
       -
       )

     

       8
       8
       -
       

     

       9
       9
       -
       // RepositoryRoutes returns repository-related routes

     

       10
       10
       -
       func RepositoryRoutes(service repository.RepositoryService) chi.Router {

     

       11
       11
       -
       	handler := handlers.NewRepositoryHandler(service)

     

       12
       12
       -
       	

     

       13
       13
       -
       	r := chi.NewRouter()

     

       14
       14
       -
       	

     

       15
       15
       -
       	// AT Protocol XRPC endpoints for repository operations

     

       16
       16
       -
       	r.Route("/xrpc", func(r chi.Router) {

     

       17
       17
       -
       		// Record operations

     

       18
       18
       -
       		r.Post("/com.atproto.repo.createRecord", handler.CreateRecord)

     

       19
       19
       -
       		r.Get("/com.atproto.repo.getRecord", handler.GetRecord)

     

       20
       20
       -
       		r.Post("/com.atproto.repo.putRecord", handler.PutRecord)

     

       21
       21
       -
       		r.Post("/com.atproto.repo.deleteRecord", handler.DeleteRecord)

     

       22
       22
       -
       		r.Get("/com.atproto.repo.listRecords", handler.ListRecords)

     

       23
       23
       -
       		

     

       24
       24
       -
       		// Repository operations

     

       25
       25
       -
       		r.Post("/com.atproto.repo.createRepo", handler.CreateRepository)

     

       26
       26
       -
       		

     

       27
       27
       -
       		// Sync operations

     

       28
       28
       -
       		r.Get("/com.atproto.sync.getRepo", handler.GetRepo)

     

       29
       29
       -
       		r.Get("/com.atproto.sync.getCommit", handler.GetCommit)

     

       30
       30
       -
       	})

     

       31
       31
       -
       	

     

       32
       32
       -
       	return r

     

       33
       33
       -
       }

-20

internal/core/repository/constants.go

···

       1
       1
       -
       package repository

     

       2
       2
       -
       

     

       3
       3
       -
       import (

     

       4
       4
       -
       	"github.com/ipfs/go-cid"

     

       5
       5
       -
       	"github.com/multiformats/go-multihash"

     

       6
       6
       -
       )

     

       7
       7
       -
       

     

       8
       8
       -
       var (

     

       9
       9
       -
       	// PlaceholderCID is used for empty repositories that have no content yet

     

       10
       10
       -
       	// This allows us to maintain consistency in the repository record

     

       11
       11
       -
       	// while the actual CAR data is created when records are added

     

       12
       12
       -
       	PlaceholderCID cid.Cid

     

       13
       13
       -
       )

     

       14
       14
       -
       

     

       15
       15
       -
       func init() {

     

       16
       16
       -
       	// Initialize the placeholder CID once at startup

     

       17
       17
       -
       	emptyData := []byte("empty")

     

       18
       18
       -
       	mh, _ := multihash.Sum(emptyData, multihash.SHA2_256, -1)

     

       19
       19
       -
       	PlaceholderCID = cid.NewCidV1(cid.Raw, mh)

     

       20
       20
       -
       }

-123

internal/core/repository/repository.go

···

       1
       1
       -
       package repository

     

       2
       2
       -
       

     

       3
       3
       -
       import (

     

       4
       4
       -
       	"time"

     

       5
       5
       -
       

     

       6
       6
       -
       	"github.com/ipfs/go-cid"

     

       7
       7
       -
       )

     

       8
       8
       -
       

     

       9
       9
       -
       // Repository represents an AT Protocol data repository

     

       10
       10
       -
       type Repository struct {

     

       11
       11
       -
       	DID            string    // Decentralized identifier of the repository owner

     

       12
       12
       -
       	HeadCID        cid.Cid   // CID of the latest commit

     

       13
       13
       -
       	Revision       string    // Current revision identifier

     

       14
       14
       -
       	RecordCount    int       // Number of records in the repository

     

       15
       15
       -
       	StorageSize    int64     // Total storage size in bytes

     

       16
       16
       -
       	CreatedAt      time.Time

     

       17
       17
       -
       	UpdatedAt      time.Time

     

       18
       18
       -
       }

     

       19
       19
       -
       

     

       20
       20
       -
       // Commit represents a signed repository commit

     

       21
       21
       -
       type Commit struct {

     

       22
       22
       -
       	CID            cid.Cid   // Content identifier of this commit

     

       23
       23
       -
       	DID            string    // DID of the committer

     

       24
       24
       -
       	Version        int       // Repository version

     

       25
       25
       -
       	PrevCID        *cid.Cid  // CID of the previous commit (nil for first commit)

     

       26
       26
       -
       	DataCID        cid.Cid   // CID of the MST root

     

       27
       27
       -
       	Revision       string    // Revision identifier

     

       28
       28
       -
       	Signature      []byte    // Cryptographic signature

     

       29
       29
       -
       	SigningKeyID   string    // Key ID used for signing

     

       30
       30
       -
       	CreatedAt      time.Time

     

       31
       31
       -
       }

     

       32
       32
       -
       

     

       33
       33
       -
       // Record represents a record in the repository

     

       34
       34
       -
       type Record struct {

     

       35
       35
       -
       	URI            string    // AT-URI of the record (e.g., at://did:plc:123/app.bsky.feed.post/abc)

     

       36
       36
       -
       	CID            cid.Cid   // Content identifier

     

       37
       37
       -
       	Collection     string    // Collection name (e.g., app.bsky.feed.post)

     

       38
       38
       -
       	RecordKey      string    // Record key within collection

     

       39
       39
       -
       	Value          []byte    // The actual record data (typically CBOR)

     

       40
       40
       -
       	CreatedAt      time.Time

     

       41
       41
       -
       	UpdatedAt      time.Time

     

       42
       42
       -
       }

     

       43
       43
       -
       

     

       44
       44
       -
       

     

       45
       45
       -
       // CreateRecordInput represents input for creating a record

     

       46
       46
       -
       type CreateRecordInput struct {

     

       47
       47
       -
       	DID            string

     

       48
       48
       -
       	Collection     string

     

       49
       49
       -
       	RecordKey      string    // Optional - will be generated if not provided

     

       50
       50
       -
       	Record         interface{}

     

       51
       51
       -
       	Validate       bool      // Whether to validate against lexicon

     

       52
       52
       -
       }

     

       53
       53
       -
       

     

       54
       54
       -
       // UpdateRecordInput represents input for updating a record

     

       55
       55
       -
       type UpdateRecordInput struct {

     

       56
       56
       -
       	DID            string

     

       57
       57
       -
       	Collection     string

     

       58
       58
       -
       	RecordKey      string

     

       59
       59
       -
       	Record         interface{}

     

       60
       60
       -
       	Validate       bool

     

       61
       61
       -
       }

     

       62
       62
       -
       

     

       63
       63
       -
       // GetRecordInput represents input for retrieving a record

     

       64
       64
       -
       type GetRecordInput struct {

     

       65
       65
       -
       	DID            string

     

       66
       66
       -
       	Collection     string

     

       67
       67
       -
       	RecordKey      string

     

       68
       68
       -
       }

     

       69
       69
       -
       

     

       70
       70
       -
       // DeleteRecordInput represents input for deleting a record

     

       71
       71
       -
       type DeleteRecordInput struct {

     

       72
       72
       -
       	DID            string

     

       73
       73
       -
       	Collection     string

     

       74
       74
       -
       	RecordKey      string

     

       75
       75
       -
       }

     

       76
       76
       -
       

     

       77
       77
       -
       // RepositoryService defines the business logic for repository operations

     

       78
       78
       -
       type RepositoryService interface {

     

       79
       79
       -
       	// Repository operations

     

       80
       80
       -
       	CreateRepository(did string) (*Repository, error)

     

       81
       81
       -
       	GetRepository(did string) (*Repository, error)

     

       82
       82
       -
       	DeleteRepository(did string) error

     

       83
       83
       -
       	

     

       84
       84
       -
       	// Record operations

     

       85
       85
       -
       	CreateRecord(input CreateRecordInput) (*Record, error)

     

       86
       86
       -
       	GetRecord(input GetRecordInput) (*Record, error)

     

       87
       87
       -
       	UpdateRecord(input UpdateRecordInput) (*Record, error)

     

       88
       88
       -
       	DeleteRecord(input DeleteRecordInput) error

     

       89
       89
       -
       	

     

       90
       90
       -
       	// Collection operations

     

       91
       91
       -
       	ListRecords(did string, collection string, limit int, cursor string) ([]*Record, string, error)

     

       92
       92
       -
       	

     

       93
       93
       -
       	// Commit operations

     

       94
       94
       -
       	GetCommit(did string, cid cid.Cid) (*Commit, error)

     

       95
       95
       -
       	ListCommits(did string, limit int, cursor string) ([]*Commit, string, error)

     

       96
       96
       -
       	

     

       97
       97
       -
       	// Export operations

     

       98
       98
       -
       	ExportRepository(did string) ([]byte, error) // Returns CAR file

     

       99
       99
       -
       	ImportRepository(did string, carData []byte) error

     

       100
       100
       -
       }

     

       101
       101
       -
       

     

       102
       102
       -
       // RepositoryRepository defines the data access interface for repositories

     

       103
       103
       -
       type RepositoryRepository interface {

     

       104
       104
       -
       	// Repository operations

     

       105
       105
       -
       	Create(repo *Repository) error

     

       106
       106
       -
       	GetByDID(did string) (*Repository, error)

     

       107
       107
       -
       	Update(repo *Repository) error

     

       108
       108
       -
       	Delete(did string) error

     

       109
       109
       -
       	

     

       110
       110
       -
       	// Commit operations

     

       111
       111
       -
       	CreateCommit(commit *Commit) error

     

       112
       112
       -
       	GetCommit(did string, cid cid.Cid) (*Commit, error)

     

       113
       113
       -
       	GetLatestCommit(did string) (*Commit, error)

     

       114
       114
       -
       	ListCommits(did string, limit int, offset int) ([]*Commit, error)

     

       115
       115
       -
       	

     

       116
       116
       -
       	// Record operations

     

       117
       117
       -
       	CreateRecord(record *Record) error

     

       118
       118
       -
       	GetRecord(did string, collection string, recordKey string) (*Record, error)

     

       119
       119
       -
       	UpdateRecord(record *Record) error

     

       120
       120
       -
       	DeleteRecord(did string, collection string, recordKey string) error

     

       121
       121
       -
       	ListRecords(did string, collection string, limit int, offset int) ([]*Record, error)

     

       122
       122
       -
       	

     

       123
       123
       -
       }

-243

internal/core/repository/service.go

···

       1
       1
       -
       package repository

     

       2
       2
       -
       

     

       3
       3
       -
       import (

     

       4
       4
       -
       	"bytes"

     

       5
       5
       -
       	"context"

     

       6
       6
       -
       	"fmt"

     

       7
       7
       -
       	"strings"

     

       8
       8
       -
       	"time"

     

       9
       9
       -
       

     

       10
       10
       -
       	"Coves/internal/atproto/carstore"

     

       11
       11
       -
       	"github.com/ipfs/go-cid"

     

       12
       12
       -
       )

     

       13
       13
       -
       

     

       14
       14
       -
       // Service implements the RepositoryService interface using Indigo's carstore

     

       15
       15
       -
       type Service struct {

     

       16
       16
       -
       	repo        RepositoryRepository

     

       17
       17
       -
       	repoStore   *carstore.RepoStore

     

       18
       18
       -
       	signingKeys map[string]interface{} // DID -> signing key

     

       19
       19
       -
       }

     

       20
       20
       -
       

     

       21
       21
       -
       // NewService creates a new repository service using carstore

     

       22
       22
       -
       func NewService(repo RepositoryRepository, repoStore *carstore.RepoStore) *Service {

     

       23
       23
       -
       	return &Service{

     

       24
       24
       -
       		repo:        repo,

     

       25
       25
       -
       		repoStore:   repoStore,

     

       26
       26
       -
       		signingKeys: make(map[string]interface{}),

     

       27
       27
       -
       	}

     

       28
       28
       -
       }

     

       29
       29
       -
       

     

       30
       30
       -
       // SetSigningKey sets the signing key for a DID

     

       31
       31
       -
       func (s *Service) SetSigningKey(did string, signingKey interface{}) {

     

       32
       32
       -
       	s.signingKeys[did] = signingKey

     

       33
       33
       -
       }

     

       34
       34
       -
       

     

       35
       35
       -
       // CreateRepository creates a new repository

     

       36
       36
       -
       func (s *Service) CreateRepository(did string) (*Repository, error) {

     

       37
       37
       -
       	// Check if repository already exists

     

       38
       38
       -
       	existing, err := s.repo.GetByDID(did)

     

       39
       39
       -
       	if err != nil {

     

       40
       40
       -
       		return nil, fmt.Errorf("checking existing repository: %w", err)

     

       41
       41
       -
       	}

     

       42
       42
       -
       	if existing != nil {

     

       43
       43
       -
       		return nil, fmt.Errorf("repository already exists for DID: %s", did)

     

       44
       44
       -
       	}

     

       45
       45
       -
       

     

       46
       46
       -
       	// For now, just create the user mapping without importing CAR data

     

       47
       47
       -
       	// The actual repository data will be created when records are added

     

       48
       48
       -
       	ctx := context.Background()

     

       49
       49
       -
       

     

       50
       50
       -
       	// Ensure user mapping exists

     

       51
       51
       -
       	_, err = s.repoStore.GetOrCreateUID(ctx, did)

     

       52
       52
       -
       	if err != nil {

     

       53
       53
       -
       		return nil, fmt.Errorf("creating user mapping: %w", err)

     

       54
       54
       -
       	}

     

       55
       55
       -
       

     

       56
       56
       -
       	// Use placeholder CID for the empty repository

     

       57
       57
       -
       

     

       58
       58
       -
       	// Create repository record

     

       59
       59
       -
       	repository := &Repository{

     

       60
       60
       -
       		DID:         did,

     

       61
       61
       -
       		HeadCID:     PlaceholderCID,

     

       62
       62
       -
       		Revision:    "rev-0",

     

       63
       63
       -
       		RecordCount: 0,

     

       64
       64
       -
       		StorageSize: 0,

     

       65
       65
       -
       		CreatedAt:   time.Now(),

     

       66
       66
       -
       		UpdatedAt:   time.Now(),

     

       67
       67
       -
       	}

     

       68
       68
       -
       

     

       69
       69
       -
       	// Save to database

     

       70
       70
       -
       	if err := s.repo.Create(repository); err != nil {

     

       71
       71
       -
       		return nil, fmt.Errorf("saving repository: %w", err)

     

       72
       72
       -
       	}

     

       73
       73
       -
       

     

       74
       74
       -
       	return repository, nil

     

       75
       75
       -
       }

     

       76
       76
       -
       

     

       77
       77
       -
       // GetRepository retrieves a repository by DID

     

       78
       78
       -
       func (s *Service) GetRepository(did string) (*Repository, error) {

     

       79
       79
       -
       	repo, err := s.repo.GetByDID(did)

     

       80
       80
       -
       	if err != nil {

     

       81
       81
       -
       		return nil, fmt.Errorf("getting repository: %w", err)

     

       82
       82
       -
       	}

     

       83
       83
       -
       	if repo == nil {

     

       84
       84
       -
       		return nil, fmt.Errorf("repository not found for DID: %s", did)

     

       85
       85
       -
       	}

     

       86
       86
       -
       

     

       87
       87
       -
       	// Update head CID from carstore

     

       88
       88
       -
       	headCID, err := s.repoStore.GetRepoHead(context.Background(), did)

     

       89
       89
       -
       	if err == nil && headCID.Defined() {

     

       90
       90
       -
       		repo.HeadCID = headCID

     

       91
       91
       -
       	}

     

       92
       92
       -
       

     

       93
       93
       -
       	return repo, nil

     

       94
       94
       -
       }

     

       95
       95
       -
       

     

       96
       96
       -
       // DeleteRepository deletes a repository

     

       97
       97
       -
       func (s *Service) DeleteRepository(did string) error {

     

       98
       98
       -
       	// Delete from carstore

     

       99
       99
       -
       	if err := s.repoStore.DeleteRepo(context.Background(), did); err != nil {

     

       100
       100
       -
       		return fmt.Errorf("deleting repo from carstore: %w", err)

     

       101
       101
       -
       	}

     

       102
       102
       -
       

     

       103
       103
       -
       	// Delete from database

     

       104
       104
       -
       	if err := s.repo.Delete(did); err != nil {

     

       105
       105
       -
       		return fmt.Errorf("deleting repository from database: %w", err)

     

       106
       106
       -
       	}

     

       107
       107
       -
       

     

       108
       108
       -
       	return nil

     

       109
       109
       -
       }

     

       110
       110
       -
       

     

       111
       111
       -
       // ExportRepository exports a repository as a CAR file

     

       112
       112
       -
       func (s *Service) ExportRepository(did string) ([]byte, error) {

     

       113
       113
       -
       	// First check if repository exists in our database

     

       114
       114
       -
       	repo, err := s.repo.GetByDID(did)

     

       115
       115
       -
       	if err != nil {

     

       116
       116
       -
       		return nil, fmt.Errorf("getting repository: %w", err)

     

       117
       117
       -
       	}

     

       118
       118
       -
       	if repo == nil {

     

       119
       119
       -
       		return nil, fmt.Errorf("repository not found for DID: %s", did)

     

       120
       120
       -
       	}

     

       121
       121
       -
       

     

       122
       122
       -
       	// Try to read from carstore

     

       123
       123
       -
       	carData, err := s.repoStore.ReadRepo(context.Background(), did, "")

     

       124
       124
       -
       	if err != nil {

     

       125
       125
       -
       		// If no data in carstore yet, return empty CAR

     

       126
       126
       -
       		// This happens when a repo is created but no records added yet

     

       127
       127
       -
       		// Check for the specific error pattern from Indigo's carstore

     

       128
       128
       -
       		errMsg := err.Error()

     

       129
       129
       -
       		if strings.Contains(errMsg, "no data found for user") ||

     

       130
       130
       -
       			strings.Contains(errMsg, "user not found") {

     

       131
       131
       -
       			return []byte{}, nil

     

       132
       132
       -
       		}

     

       133
       133
       -
       		return nil, fmt.Errorf("exporting repository: %w", err)

     

       134
       134
       -
       	}

     

       135
       135
       -
       

     

       136
       136
       -
       	return carData, nil

     

       137
       137
       -
       }

     

       138
       138
       -
       

     

       139
       139
       -
       // ImportRepository imports a repository from a CAR file

     

       140
       140
       -
       func (s *Service) ImportRepository(did string, carData []byte) error {

     

       141
       141
       -
       	ctx := context.Background()

     

       142
       142
       -
       

     

       143
       143
       -
       	// If empty CAR data, just create user mapping

     

       144
       144
       -
       	if len(carData) == 0 {

     

       145
       145
       -
       		_, err := s.repoStore.GetOrCreateUID(ctx, did)

     

       146
       146
       -
       		if err != nil {

     

       147
       147
       -
       			return fmt.Errorf("creating user mapping: %w", err)

     

       148
       148
       -
       		}

     

       149
       149
       -
       

     

       150
       150
       -
       		// Use placeholder CID for empty repository

     

       151
       151
       -
       		headCID := PlaceholderCID

     

       152
       152
       -
       

     

       153
       153
       -
       		// Create repository record

     

       154
       154
       -
       		repo := &Repository{

     

       155
       155
       -
       			DID:         did,

     

       156
       156
       -
       			HeadCID:     headCID,

     

       157
       157
       -
       			Revision:    "imported-empty",

     

       158
       158
       -
       			RecordCount: 0,

     

       159
       159
       -
       			StorageSize: 0,

     

       160
       160
       -
       			CreatedAt:   time.Now(),

     

       161
       161
       -
       			UpdatedAt:   time.Now(),

     

       162
       162
       -
       		}

     

       163
       163
       -
       		if err := s.repo.Create(repo); err != nil {

     

       164
       164
       -
       			return fmt.Errorf("creating repository: %w", err)

     

       165
       165
       -
       		}

     

       166
       166
       -
       		return nil

     

       167
       167
       -
       	}

     

       168
       168
       -
       

     

       169
       169
       -
       	// Import non-empty CAR into carstore

     

       170
       170
       -
       	headCID, err := s.repoStore.ImportRepo(ctx, did, bytes.NewReader(carData))

     

       171
       171
       -
       	if err != nil {

     

       172
       172
       -
       		return fmt.Errorf("importing repository: %w", err)

     

       173
       173
       -
       	}

     

       174
       174
       -
       

     

       175
       175
       -
       	// Create or update repository record

     

       176
       176
       -
       	repo, err := s.repo.GetByDID(did)

     

       177
       177
       -
       	if err != nil {

     

       178
       178
       -
       		return fmt.Errorf("getting repository: %w", err)

     

       179
       179
       -
       	}

     

       180
       180
       -
       

     

       181
       181
       -
       	if repo == nil {

     

       182
       182
       -
       		// Create new repository

     

       183
       183
       -
       		repo = &Repository{

     

       184
       184
       -
       			DID:         did,

     

       185
       185
       -
       			HeadCID:     headCID,

     

       186
       186
       -
       			Revision:    "imported",

     

       187
       187
       -
       			RecordCount: 0, // TODO: Count records in CAR

     

       188
       188
       -
       			StorageSize: int64(len(carData)),

     

       189
       189
       -
       			CreatedAt:   time.Now(),

     

       190
       190
       -
       			UpdatedAt:   time.Now(),

     

       191
       191
       -
       		}

     

       192
       192
       -
       		if err := s.repo.Create(repo); err != nil {

     

       193
       193
       -
       			return fmt.Errorf("creating repository: %w", err)

     

       194
       194
       -
       		}

     

       195
       195
       -
       	} else {

     

       196
       196
       -
       		// Update existing repository

     

       197
       197
       -
       		repo.HeadCID = headCID

     

       198
       198
       -
       		repo.UpdatedAt = time.Now()

     

       199
       199
       -
       		if err := s.repo.Update(repo); err != nil {

     

       200
       200
       -
       			return fmt.Errorf("updating repository: %w", err)

     

       201
       201
       -
       		}

     

       202
       202
       -
       	}

     

       203
       203
       -
       

     

       204
       204
       -
       	return nil

     

       205
       205
       -
       }

     

       206
       206
       -
       

     

       207
       207
       -
       // CompactRepository runs garbage collection on a repository

     

       208
       208
       -
       func (s *Service) CompactRepository(did string) error {

     

       209
       209
       -
       	return s.repoStore.CompactRepo(context.Background(), did)

     

       210
       210
       -
       }

     

       211
       211
       -
       

     

       212
       212
       -
       // Note: Record-level operations would require more complex implementation

     

       213
       213
       -
       // to work with the carstore. For now, these are placeholder implementations

     

       214
       214
       -
       // that would need to be expanded to properly handle record CRUD operations

     

       215
       215
       -
       // by reading the CAR, modifying the repo structure, and writing back.

     

       216
       216
       -
       

     

       217
       217
       -
       func (s *Service) CreateRecord(input CreateRecordInput) (*Record, error) {

     

       218
       218
       -
       	return nil, fmt.Errorf("record operations not yet implemented for carstore")

     

       219
       219
       -
       }

     

       220
       220
       -
       

     

       221
       221
       -
       func (s *Service) GetRecord(input GetRecordInput) (*Record, error) {

     

       222
       222
       -
       	return nil, fmt.Errorf("record operations not yet implemented for carstore")

     

       223
       223
       -
       }

     

       224
       224
       -
       

     

       225
       225
       -
       func (s *Service) UpdateRecord(input UpdateRecordInput) (*Record, error) {

     

       226
       226
       -
       	return nil, fmt.Errorf("record operations not yet implemented for carstore")

     

       227
       227
       -
       }

     

       228
       228
       -
       

     

       229
       229
       -
       func (s *Service) DeleteRecord(input DeleteRecordInput) error {

     

       230
       230
       -
       	return fmt.Errorf("record operations not yet implemented for carstore")

     

       231
       231
       -
       }

     

       232
       232
       -
       

     

       233
       233
       -
       func (s *Service) ListRecords(did string, collection string, limit int, cursor string) ([]*Record, string, error) {

     

       234
       234
       -
       	return nil, "", fmt.Errorf("record operations not yet implemented for carstore")

     

       235
       235
       -
       }

     

       236
       236
       -
       

     

       237
       237
       -
       func (s *Service) GetCommit(did string, commitCID cid.Cid) (*Commit, error) {

     

       238
       238
       -
       	return nil, fmt.Errorf("commit operations not yet implemented for carstore")

     

       239
       239
       -
       }

     

       240
       240
       -
       

     

       241
       241
       -
       func (s *Service) ListCommits(did string, limit int, cursor string) ([]*Commit, string, error) {

     

       242
       242
       -
       	return nil, "", fmt.Errorf("commit operations not yet implemented for carstore")

     

       243
       243
       -
       }

-513

internal/core/repository/service_test.go

···

       1
       1
       -
       package repository_test

     

       2
       2
       -
       

     

       3
       3
       -
       import (

     

       4
       4
       -
       	"context"

     

       5
       5
       -
       	"database/sql"

     

       6
       6
       -
       	"fmt"

     

       7
       7
       -
       	"os"

     

       8
       8
       -
       	"testing"

     

       9
       9
       -
       

     

       10
       10
       -
       	"Coves/internal/atproto/carstore"

     

       11
       11
       -
       	"Coves/internal/core/repository"

     

       12
       12
       -
       	"Coves/internal/db/postgres"

     

       13
       13
       -
       

     

       14
       14
       -
       	"github.com/ipfs/go-cid"

     

       15
       15
       -
       	_ "github.com/lib/pq"

     

       16
       16
       -
       	"github.com/pressly/goose/v3"

     

       17
       17
       -
       	postgresDriver "gorm.io/driver/postgres"

     

       18
       18
       -
       	"gorm.io/gorm"

     

       19
       19
       -
       )

     

       20
       20
       -
       

     

       21
       21
       -
       // Mock signing key for testing

     

       22
       22
       -
       type mockSigningKey struct{}

     

       23
       23
       -
       

     

       24
       24
       -
       // Test database connection

     

       25
       25
       -
       func setupTestDB(t *testing.T) (*sql.DB, *gorm.DB, func()) {

     

       26
       26
       -
       	// Use test database URL from environment or default

     

       27
       27
       -
       	dbURL := os.Getenv("TEST_DATABASE_URL")

     

       28
       28
       -
       	if dbURL == "" {

     

       29
       29
       -
       		// Skip test if no database configured

     

       30
       30
       -
       		t.Skip("TEST_DATABASE_URL not set, skipping database tests")

     

       31
       31
       -
       	}

     

       32
       32
       -
       

     

       33
       33
       -
       	// Connect with sql.DB for migrations

     

       34
       34
       -
       	sqlDB, err := sql.Open("postgres", dbURL)

     

       35
       35
       -
       	if err != nil {

     

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

     

       37
       37
       -
       	}

     

       38
       38
       -
       

     

       39
       39
       -
       	// Run migrations

     

       40
       40
       -
       	if err := goose.Up(sqlDB, "../../db/migrations"); err != nil {

     

       41
       41
       -
       		t.Fatalf("Failed to run migrations: %v", err)

     

       42
       42
       -
       	}

     

       43
       43
       -
       

     

       44
       44
       -
       	// Connect with GORM using a fresh connection

     

       45
       45
       -
       	gormDB, err := gorm.Open(postgresDriver.Open(dbURL), &gorm.Config{

     

       46
       46
       -
       		DisableForeignKeyConstraintWhenMigrating: true,

     

       47
       47
       -
       		PrepareStmt:                              false,

     

       48
       48
       -
       	})

     

       49
       49
       -
       	if err != nil {

     

       50
       50
       -
       		t.Fatalf("Failed to create GORM connection: %v", err)

     

       51
       51
       -
       	}

     

       52
       52
       -
       

     

       53
       53
       -
       	// Cleanup function

     

       54
       54
       -
       	cleanup := func() {

     

       55
       55
       -
       		// Clean up test data

     

       56
       56
       -
       		gormDB.Exec("DELETE FROM repositories")

     

       57
       57
       -
       		gormDB.Exec("DELETE FROM commits")

     

       58
       58
       -
       		gormDB.Exec("DELETE FROM records")

     

       59
       59
       -
       		gormDB.Exec("DELETE FROM user_maps")

     

       60
       60
       -
       		gormDB.Exec("DELETE FROM car_shards")

     

       61
       61
       -
       		gormDB.Exec("DELETE FROM block_refs")

     

       62
       62
       -
       

     

       63
       63
       -
       		// Close GORM connection

     

       64
       64
       -
       		if sqlGormDB, err := gormDB.DB(); err == nil {

     

       65
       65
       -
       			sqlGormDB.Close()

     

       66
       66
       -
       		}

     

       67
       67
       -
       

     

       68
       68
       -
       		// Close original SQL connection

     

       69
       69
       -
       		sqlDB.Close()

     

       70
       70
       -
       	}

     

       71
       71
       -
       

     

       72
       72
       -
       	return sqlDB, gormDB, cleanup

     

       73
       73
       -
       }

     

       74
       74
       -
       

     

       75
       75
       -
       func TestRepositoryService_CreateRepository(t *testing.T) {

     

       76
       76
       -
       	sqlDB, gormDB, cleanup := setupTestDB(t)

     

       77
       77
       -
       	defer cleanup()

     

       78
       78
       -
       

     

       79
       79
       -
       	// Create temporary directory for carstore

     

       80
       80
       -
       	tempDir, err := os.MkdirTemp("", "carstore_test")

     

       81
       81
       -
       	if err != nil {

     

       82
       82
       -
       		t.Fatalf("Failed to create temp dir: %v", err)

     

       83
       83
       -
       	}

     

       84
       84
       -
       	defer os.RemoveAll(tempDir)

     

       85
       85
       -
       

     

       86
       86
       -
       	// Initialize carstore

     

       87
       87
       -
       	carDirs := []string{tempDir}

     

       88
       88
       -
       	repoStore, err := carstore.NewRepoStore(gormDB, carDirs)

     

       89
       89
       -
       	if err != nil {

     

       90
       90
       -
       		t.Fatalf("Failed to create repo store: %v", err)

     

       91
       91
       -
       	}

     

       92
       92
       -
       

     

       93
       93
       -
       	// Initialize repository service

     

       94
       94
       -
       	repoRepo := postgres.NewRepositoryRepo(sqlDB)

     

       95
       95
       -
       	service := repository.NewService(repoRepo, repoStore)

     

       96
       96
       -
       

     

       97
       97
       -
       	// Test DID

     

       98
       98
       -
       	testDID := "did:plc:testuser123"

     

       99
       99
       -
       

     

       100
       100
       -
       	// Set signing key

     

       101
       101
       -
       	service.SetSigningKey(testDID, &mockSigningKey{})

     

       102
       102
       -
       

     

       103
       103
       -
       	// Create repository

     

       104
       104
       -
       	repo, err := service.CreateRepository(testDID)

     

       105
       105
       -
       	if err != nil {

     

       106
       106
       -
       		t.Fatalf("Failed to create repository: %v", err)

     

       107
       107
       -
       	}

     

       108
       108
       -
       

     

       109
       109
       -
       	// Verify repository was created

     

       110
       110
       -
       	if repo.DID != testDID {

     

       111
       111
       -
       		t.Errorf("Expected DID %s, got %s", testDID, repo.DID)

     

       112
       112
       -
       	}

     

       113
       113
       -
       	if !repo.HeadCID.Defined() {

     

       114
       114
       -
       		t.Error("Expected HeadCID to be defined")

     

       115
       115
       -
       	}

     

       116
       116
       -
       	if repo.RecordCount != 0 {

     

       117
       117
       -
       		t.Errorf("Expected RecordCount 0, got %d", repo.RecordCount)

     

       118
       118
       -
       	}

     

       119
       119
       -
       

     

       120
       120
       -
       	// Verify repository exists in database

     

       121
       121
       -
       	fetchedRepo, err := service.GetRepository(testDID)

     

       122
       122
       -
       	if err != nil {

     

       123
       123
       -
       		t.Fatalf("Failed to get repository: %v", err)

     

       124
       124
       -
       	}

     

       125
       125
       -
       	if fetchedRepo.DID != testDID {

     

       126
       126
       -
       		t.Errorf("Expected fetched DID %s, got %s", testDID, fetchedRepo.DID)

     

       127
       127
       -
       	}

     

       128
       128
       -
       

     

       129
       129
       -
       	// Test duplicate creation should fail

     

       130
       130
       -
       	_, err = service.CreateRepository(testDID)

     

       131
       131
       -
       	if err == nil {

     

       132
       132
       -
       		t.Error("Expected error creating duplicate repository")

     

       133
       133
       -
       	}

     

       134
       134
       -
       }

     

       135
       135
       -
       

     

       136
       136
       -
       func TestRepositoryService_ImportExport(t *testing.T) {

     

       137
       137
       -
       	sqlDB, gormDB, cleanup := setupTestDB(t)

     

       138
       138
       -
       	defer cleanup()

     

       139
       139
       -
       

     

       140
       140
       -
       	// Create temporary directory for carstore

     

       141
       141
       -
       	tempDir, err := os.MkdirTemp("", "carstore_test")

     

       142
       142
       -
       	if err != nil {

     

       143
       143
       -
       		t.Fatalf("Failed to create temp dir: %v", err)

     

       144
       144
       -
       	}

     

       145
       145
       -
       	defer os.RemoveAll(tempDir)

     

       146
       146
       -
       

     

       147
       147
       -
       	// Log the temp directory for debugging

     

       148
       148
       -
       	t.Logf("Using carstore directory: %s", tempDir)

     

       149
       149
       -
       

     

       150
       150
       -
       	// Initialize carstore

     

       151
       151
       -
       	carDirs := []string{tempDir}

     

       152
       152
       -
       	repoStore, err := carstore.NewRepoStore(gormDB, carDirs)

     

       153
       153
       -
       	if err != nil {

     

       154
       154
       -
       		t.Fatalf("Failed to create repo store: %v", err)

     

       155
       155
       -
       	}

     

       156
       156
       -
       

     

       157
       157
       -
       	// Initialize repository service

     

       158
       158
       -
       	repoRepo := postgres.NewRepositoryRepo(sqlDB)

     

       159
       159
       -
       	service := repository.NewService(repoRepo, repoStore)

     

       160
       160
       -
       

     

       161
       161
       -
       	// Create first repository

     

       162
       162
       -
       	did1 := "did:plc:user1"

     

       163
       163
       -
       	service.SetSigningKey(did1, &mockSigningKey{})

     

       164
       164
       -
       	repo1, err := service.CreateRepository(did1)

     

       165
       165
       -
       	if err != nil {

     

       166
       166
       -
       		t.Fatalf("Failed to create repository 1: %v", err)

     

       167
       167
       -
       	}

     

       168
       168
       -
       	t.Logf("Created repository with HeadCID: %s", repo1.HeadCID)

     

       169
       169
       -
       

     

       170
       170
       -
       	// Check what's in the database

     

       171
       171
       -
       	var userMapCount int

     

       172
       172
       -
       	gormDB.Raw("SELECT COUNT(*) FROM user_maps").Scan(&userMapCount)

     

       173
       173
       -
       	t.Logf("User maps count: %d", userMapCount)

     

       174
       174
       -
       

     

       175
       175
       -
       	var carShardCount int

     

       176
       176
       -
       	gormDB.Raw("SELECT COUNT(*) FROM car_shards").Scan(&carShardCount)

     

       177
       177
       -
       	t.Logf("Car shards count: %d", carShardCount)

     

       178
       178
       -
       

     

       179
       179
       -
       	// Check block_refs too

     

       180
       180
       -
       	var blockRefCount int

     

       181
       181
       -
       	gormDB.Raw("SELECT COUNT(*) FROM block_refs").Scan(&blockRefCount)

     

       182
       182
       -
       	t.Logf("Block refs count: %d", blockRefCount)

     

       183
       183
       -
       

     

       184
       184
       -
       	// Export repository

     

       185
       185
       -
       	carData, err := service.ExportRepository(did1)

     

       186
       186
       -
       	if err != nil {

     

       187
       187
       -
       		t.Fatalf("Failed to export repository: %v", err)

     

       188
       188
       -
       	}

     

       189
       189
       -
       	// For now, empty repositories return empty CAR data

     

       190
       190
       -
       	t.Logf("Exported CAR data size: %d bytes", len(carData))

     

       191
       191
       -
       

     

       192
       192
       -
       	// Import to new DID

     

       193
       193
       -
       	did2 := "did:plc:user2"

     

       194
       194
       -
       	err = service.ImportRepository(did2, carData)

     

       195
       195
       -
       	if err != nil {

     

       196
       196
       -
       		t.Fatalf("Failed to import repository: %v", err)

     

       197
       197
       -
       	}

     

       198
       198
       -
       

     

       199
       199
       -
       	// Verify imported repository

     

       200
       200
       -
       	repo2, err := service.GetRepository(did2)

     

       201
       201
       -
       	if err != nil {

     

       202
       202
       -
       		t.Fatalf("Failed to get imported repository: %v", err)

     

       203
       203
       -
       	}

     

       204
       204
       -
       	if repo2.DID != did2 {

     

       205
       205
       -
       		t.Errorf("Expected DID %s, got %s", did2, repo2.DID)

     

       206
       206
       -
       	}

     

       207
       207
       -
       	// Note: HeadCID might differ due to new import

     

       208
       208
       -
       }

     

       209
       209
       -
       

     

       210
       210
       -
       func TestRepositoryService_DeleteRepository(t *testing.T) {

     

       211
       211
       -
       	sqlDB, gormDB, cleanup := setupTestDB(t)

     

       212
       212
       -
       	defer cleanup()

     

       213
       213
       -
       

     

       214
       214
       -
       	// Create temporary directory for carstore

     

       215
       215
       -
       	tempDir, err := os.MkdirTemp("", "carstore_test")

     

       216
       216
       -
       	if err != nil {

     

       217
       217
       -
       		t.Fatalf("Failed to create temp dir: %v", err)

     

       218
       218
       -
       	}

     

       219
       219
       -
       	defer os.RemoveAll(tempDir)

     

       220
       220
       -
       

     

       221
       221
       -
       	// Initialize carstore

     

       222
       222
       -
       	carDirs := []string{tempDir}

     

       223
       223
       -
       	repoStore, err := carstore.NewRepoStore(gormDB, carDirs)

     

       224
       224
       -
       	if err != nil {

     

       225
       225
       -
       		t.Fatalf("Failed to create repo store: %v", err)

     

       226
       226
       -
       	}

     

       227
       227
       -
       

     

       228
       228
       -
       	// Initialize repository service

     

       229
       229
       -
       	repoRepo := postgres.NewRepositoryRepo(sqlDB)

     

       230
       230
       -
       	service := repository.NewService(repoRepo, repoStore)

     

       231
       231
       -
       

     

       232
       232
       -
       	// Create repository

     

       233
       233
       -
       	testDID := "did:plc:deletetest"

     

       234
       234
       -
       	service.SetSigningKey(testDID, &mockSigningKey{})

     

       235
       235
       -
       	_, err = service.CreateRepository(testDID)

     

       236
       236
       -
       	if err != nil {

     

       237
       237
       -
       		t.Fatalf("Failed to create repository: %v", err)

     

       238
       238
       -
       	}

     

       239
       239
       -
       

     

       240
       240
       -
       	// Delete repository

     

       241
       241
       -
       	err = service.DeleteRepository(testDID)

     

       242
       242
       -
       	if err != nil {

     

       243
       243
       -
       		t.Fatalf("Failed to delete repository: %v", err)

     

       244
       244
       -
       	}

     

       245
       245
       -
       

     

       246
       246
       -
       	// Verify repository is deleted

     

       247
       247
       -
       	_, err = service.GetRepository(testDID)

     

       248
       248
       -
       	if err == nil {

     

       249
       249
       -
       		t.Error("Expected error getting deleted repository")

     

       250
       250
       -
       	}

     

       251
       251
       -
       }

     

       252
       252
       -
       

     

       253
       253
       -
       func TestRepositoryService_CompactRepository(t *testing.T) {

     

       254
       254
       -
       	sqlDB, gormDB, cleanup := setupTestDB(t)

     

       255
       255
       -
       	defer cleanup()

     

       256
       256
       -
       

     

       257
       257
       -
       	// Create temporary directory for carstore

     

       258
       258
       -
       	tempDir, err := os.MkdirTemp("", "carstore_test")

     

       259
       259
       -
       	if err != nil {

     

       260
       260
       -
       		t.Fatalf("Failed to create temp dir: %v", err)

     

       261
       261
       -
       	}

     

       262
       262
       -
       	defer os.RemoveAll(tempDir)

     

       263
       263
       -
       

     

       264
       264
       -
       	// Initialize carstore

     

       265
       265
       -
       	carDirs := []string{tempDir}

     

       266
       266
       -
       	repoStore, err := carstore.NewRepoStore(gormDB, carDirs)

     

       267
       267
       -
       	if err != nil {

     

       268
       268
       -
       		t.Fatalf("Failed to create repo store: %v", err)

     

       269
       269
       -
       	}

     

       270
       270
       -
       

     

       271
       271
       -
       	// Initialize repository service

     

       272
       272
       -
       	repoRepo := postgres.NewRepositoryRepo(sqlDB)

     

       273
       273
       -
       	service := repository.NewService(repoRepo, repoStore)

     

       274
       274
       -
       

     

       275
       275
       -
       	// Create repository

     

       276
       276
       -
       	testDID := "did:plc:compacttest"

     

       277
       277
       -
       	service.SetSigningKey(testDID, &mockSigningKey{})

     

       278
       278
       -
       	_, err = service.CreateRepository(testDID)

     

       279
       279
       -
       	if err != nil {

     

       280
       280
       -
       		t.Fatalf("Failed to create repository: %v", err)

     

       281
       281
       -
       	}

     

       282
       282
       -
       

     

       283
       283
       -
       	// Run compaction (should not error even with minimal data)

     

       284
       284
       -
       	err = service.CompactRepository(testDID)

     

       285
       285
       -
       	if err != nil {

     

       286
       286
       -
       		t.Errorf("Failed to compact repository: %v", err)

     

       287
       287
       -
       	}

     

       288
       288
       -
       }

     

       289
       289
       -
       

     

       290
       290
       -
       // Test UserMapping functionality

     

       291
       291
       -
       func TestUserMapping(t *testing.T) {

     

       292
       292
       -
       	_, gormDB, cleanup := setupTestDB(t)

     

       293
       293
       -
       	defer cleanup()

     

       294
       294
       -
       

     

       295
       295
       -
       	// Create user mapping

     

       296
       296
       -
       	mapping, err := carstore.NewUserMapping(gormDB)

     

       297
       297
       -
       	if err != nil {

     

       298
       298
       -
       		t.Fatalf("Failed to create user mapping: %v", err)

     

       299
       299
       -
       	}

     

       300
       300
       -
       

     

       301
       301
       -
       	// Test creating new mapping

     

       302
       302
       -
       	did1 := "did:plc:mapping1"

     

       303
       303
       -
       	uid1, err := mapping.GetOrCreateUID(context.Background(), did1)

     

       304
       304
       -
       	if err != nil {

     

       305
       305
       -
       		t.Fatalf("Failed to create UID for %s: %v", did1, err)

     

       306
       306
       -
       	}

     

       307
       307
       -
       	if uid1 == 0 {

     

       308
       308
       -
       		t.Error("Expected non-zero UID")

     

       309
       309
       -
       	}

     

       310
       310
       -
       

     

       311
       311
       -
       	// Test getting existing mapping

     

       312
       312
       -
       	uid1Again, err := mapping.GetOrCreateUID(context.Background(), did1)

     

       313
       313
       -
       	if err != nil {

     

       314
       314
       -
       		t.Fatalf("Failed to get UID for %s: %v", did1, err)

     

       315
       315
       -
       	}

     

       316
       316
       -
       	if uid1 != uid1Again {

     

       317
       317
       -
       		t.Errorf("Expected same UID, got %d and %d", uid1, uid1Again)

     

       318
       318
       -
       	}

     

       319
       319
       -
       

     

       320
       320
       -
       	// Test reverse lookup

     

       321
       321
       -
       	didLookup, err := mapping.GetDID(uid1)

     

       322
       322
       -
       	if err != nil {

     

       323
       323
       -
       		t.Fatalf("Failed to get DID for UID %d: %v", uid1, err)

     

       324
       324
       -
       	}

     

       325
       325
       -
       	if didLookup != did1 {

     

       326
       326
       -
       		t.Errorf("Expected DID %s, got %s", did1, didLookup)

     

       327
       327
       -
       	}

     

       328
       328
       -
       

     

       329
       329
       -
       	// Test second user gets different UID

     

       330
       330
       -
       	did2 := "did:plc:mapping2"

     

       331
       331
       -
       	uid2, err := mapping.GetOrCreateUID(context.Background(), did2)

     

       332
       332
       -
       	if err != nil {

     

       333
       333
       -
       		t.Fatalf("Failed to create UID for %s: %v", did2, err)

     

       334
       334
       -
       	}

     

       335
       335
       -
       	if uid2 == uid1 {

     

       336
       336
       -
       		t.Error("Expected different UIDs for different DIDs")

     

       337
       337
       -
       	}

     

       338
       338
       -
       }

     

       339
       339
       -
       

     

       340
       340
       -
       // Test with mock repository and carstore

     

       341
       341
       -
       func TestRepositoryService_MockedComponents(t *testing.T) {

     

       342
       342
       -
       	// Use the existing mock repository from the old test file

     

       343
       343
       -
       	_ = NewMockRepositoryRepository()

     

       344
       344
       -
       

     

       345
       345
       -
       	// For unit testing without real carstore, we would need to mock RepoStore

     

       346
       346
       -
       	// For now, this demonstrates the structure

     

       347
       347
       -
       	t.Skip("Mocked carstore tests would require creating mock RepoStore interface")

     

       348
       348
       -
       }

     

       349
       349
       -
       

     

       350
       350
       -
       // Benchmark repository creation

     

       351
       351
       -
       func BenchmarkRepositoryCreation(b *testing.B) {

     

       352
       352
       -
       	sqlDB, gormDB, cleanup := setupTestDB(&testing.T{})

     

       353
       353
       -
       	defer cleanup()

     

       354
       354
       -
       

     

       355
       355
       -
       	tempDir, _ := os.MkdirTemp("", "carstore_bench")

     

       356
       356
       -
       	defer os.RemoveAll(tempDir)

     

       357
       357
       -
       

     

       358
       358
       -
       	carDirs := []string{tempDir}

     

       359
       359
       -
       	repoStore, _ := carstore.NewRepoStore(gormDB, carDirs)

     

       360
       360
       -
       	repoRepo := postgres.NewRepositoryRepo(sqlDB)

     

       361
       361
       -
       	service := repository.NewService(repoRepo, repoStore)

     

       362
       362
       -
       

     

       363
       363
       -
       	b.ResetTimer()

     

       364
       364
       -
       	for i := 0; i < b.N; i++ {

     

       365
       365
       -
       		did := fmt.Sprintf("did:plc:bench%d", i)

     

       366
       366
       -
       		service.SetSigningKey(did, &mockSigningKey{})

     

       367
       367
       -
       		_, _ = service.CreateRepository(did)

     

       368
       368
       -
       	}

     

       369
       369
       -
       }

     

       370
       370
       -
       

     

       371
       371
       -
       // MockRepositoryRepository is a mock implementation of repository.RepositoryRepository

     

       372
       372
       -
       type MockRepositoryRepository struct {

     

       373
       373
       -
       	repositories map[string]*repository.Repository

     

       374
       374
       -
       	commits      map[string][]*repository.Commit

     

       375
       375
       -
       	records      map[string]*repository.Record

     

       376
       376
       -
       }

     

       377
       377
       -
       

     

       378
       378
       -
       func NewMockRepositoryRepository() *MockRepositoryRepository {

     

       379
       379
       -
       	return &MockRepositoryRepository{

     

       380
       380
       -
       		repositories: make(map[string]*repository.Repository),

     

       381
       381
       -
       		commits:      make(map[string][]*repository.Commit),

     

       382
       382
       -
       		records:      make(map[string]*repository.Record),

     

       383
       383
       -
       	}

     

       384
       384
       -
       }

     

       385
       385
       -
       

     

       386
       386
       -
       // Repository operations

     

       387
       387
       -
       func (m *MockRepositoryRepository) Create(repo *repository.Repository) error {

     

       388
       388
       -
       	m.repositories[repo.DID] = repo

     

       389
       389
       -
       	return nil

     

       390
       390
       -
       }

     

       391
       391
       -
       

     

       392
       392
       -
       func (m *MockRepositoryRepository) GetByDID(did string) (*repository.Repository, error) {

     

       393
       393
       -
       	repo, exists := m.repositories[did]

     

       394
       394
       -
       	if !exists {

     

       395
       395
       -
       		return nil, nil

     

       396
       396
       -
       	}

     

       397
       397
       -
       	return repo, nil

     

       398
       398
       -
       }

     

       399
       399
       -
       

     

       400
       400
       -
       func (m *MockRepositoryRepository) Update(repo *repository.Repository) error {

     

       401
       401
       -
       	if _, exists := m.repositories[repo.DID]; !exists {

     

       402
       402
       -
       		return nil

     

       403
       403
       -
       	}

     

       404
       404
       -
       	m.repositories[repo.DID] = repo

     

       405
       405
       -
       	return nil

     

       406
       406
       -
       }

     

       407
       407
       -
       

     

       408
       408
       -
       func (m *MockRepositoryRepository) Delete(did string) error {

     

       409
       409
       -
       	delete(m.repositories, did)

     

       410
       410
       -
       	return nil

     

       411
       411
       -
       }

     

       412
       412
       -
       

     

       413
       413
       -
       // Commit operations

     

       414
       414
       -
       func (m *MockRepositoryRepository) CreateCommit(commit *repository.Commit) error {

     

       415
       415
       -
       	m.commits[commit.DID] = append(m.commits[commit.DID], commit)

     

       416
       416
       -
       	return nil

     

       417
       417
       -
       }

     

       418
       418
       -
       

     

       419
       419
       -
       func (m *MockRepositoryRepository) GetCommit(did string, commitCID cid.Cid) (*repository.Commit, error) {

     

       420
       420
       -
       	commits, exists := m.commits[did]

     

       421
       421
       -
       	if !exists {

     

       422
       422
       -
       		return nil, nil

     

       423
       423
       -
       	}

     

       424
       424
       -
       

     

       425
       425
       -
       	for _, c := range commits {

     

       426
       426
       -
       		if c.CID.Equals(commitCID) {

     

       427
       427
       -
       			return c, nil

     

       428
       428
       -
       		}

     

       429
       429
       -
       	}

     

       430
       430
       -
       	return nil, nil

     

       431
       431
       -
       }

     

       432
       432
       -
       

     

       433
       433
       -
       func (m *MockRepositoryRepository) GetLatestCommit(did string) (*repository.Commit, error) {

     

       434
       434
       -
       	commits, exists := m.commits[did]

     

       435
       435
       -
       	if !exists || len(commits) == 0 {

     

       436
       436
       -
       		return nil, nil

     

       437
       437
       -
       	}

     

       438
       438
       -
       	return commits[len(commits)-1], nil

     

       439
       439
       -
       }

     

       440
       440
       -
       

     

       441
       441
       -
       func (m *MockRepositoryRepository) ListCommits(did string, limit int, offset int) ([]*repository.Commit, error) {

     

       442
       442
       -
       	commits, exists := m.commits[did]

     

       443
       443
       -
       	if !exists {

     

       444
       444
       -
       		return []*repository.Commit{}, nil

     

       445
       445
       -
       	}

     

       446
       446
       -
       

     

       447
       447
       -
       	start := offset

     

       448
       448
       -
       	if start >= len(commits) {

     

       449
       449
       -
       		return []*repository.Commit{}, nil

     

       450
       450
       -
       	}

     

       451
       451
       -
       

     

       452
       452
       -
       	end := start + limit

     

       453
       453
       -
       	if end > len(commits) {

     

       454
       454
       -
       		end = len(commits)

     

       455
       455
       -
       	}

     

       456
       456
       -
       

     

       457
       457
       -
       	return commits[start:end], nil

     

       458
       458
       -
       }

     

       459
       459
       -
       

     

       460
       460
       -
       // Record operations

     

       461
       461
       -
       func (m *MockRepositoryRepository) CreateRecord(record *repository.Record) error {

     

       462
       462
       -
       	key := record.URI

     

       463
       463
       -
       	m.records[key] = record

     

       464
       464
       -
       	return nil

     

       465
       465
       -
       }

     

       466
       466
       -
       

     

       467
       467
       -
       func (m *MockRepositoryRepository) GetRecord(did string, collection string, recordKey string) (*repository.Record, error) {

     

       468
       468
       -
       	uri := "at://" + did + "/" + collection + "/" + recordKey

     

       469
       469
       -
       	record, exists := m.records[uri]

     

       470
       470
       -
       	if !exists {

     

       471
       471
       -
       		return nil, nil

     

       472
       472
       -
       	}

     

       473
       473
       -
       	return record, nil

     

       474
       474
       -
       }

     

       475
       475
       -
       

     

       476
       476
       -
       func (m *MockRepositoryRepository) UpdateRecord(record *repository.Record) error {

     

       477
       477
       -
       	key := record.URI

     

       478
       478
       -
       	if _, exists := m.records[key]; !exists {

     

       479
       479
       -
       		return nil

     

       480
       480
       -
       	}

     

       481
       481
       -
       	m.records[key] = record

     

       482
       482
       -
       	return nil

     

       483
       483
       -
       }

     

       484
       484
       -
       

     

       485
       485
       -
       func (m *MockRepositoryRepository) DeleteRecord(did string, collection string, recordKey string) error {

     

       486
       486
       -
       	uri := "at://" + did + "/" + collection + "/" + recordKey

     

       487
       487
       -
       	delete(m.records, uri)

     

       488
       488
       -
       	return nil

     

       489
       489
       -
       }

     

       490
       490
       -
       

     

       491
       491
       -
       func (m *MockRepositoryRepository) ListRecords(did string, collection string, limit int, offset int) ([]*repository.Record, error) {

     

       492
       492
       -
       	var records []*repository.Record

     

       493
       493
       -
       	prefix := "at://" + did + "/" + collection + "/"

     

       494
       494
       -
       

     

       495
       495
       -
       	for uri, record := range m.records {

     

       496
       496
       -
       		if len(uri) > len(prefix) && uri[:len(prefix)] == prefix {

     

       497
       497
       -
       			records = append(records, record)

     

       498
       498
       -
       		}

     

       499
       499
       -
       	}

     

       500
       500
       -
       

     

       501
       501
       -
       	// Simple pagination

     

       502
       502
       -
       	start := offset

     

       503
       503
       -
       	if start >= len(records) {

     

       504
       504
       -
       		return []*repository.Record{}, nil

     

       505
       505
       -
       	}

     

       506
       506
       -
       

     

       507
       507
       -
       	end := start + limit

     

       508
       508
       -
       	if end > len(records) {

     

       509
       509
       -
       		end = len(records)

     

       510
       510
       -
       	}

     

       511
       511
       -
       

     

       512
       512
       -
       	return records[start:end], nil

     

       513
       513
       -
       }

-12

internal/db/local_dev_db_compose/docker-compose.yml

···

       1
       1
       -
       # docker-compose.yml

     

       2
       2
       -
       services:

     

       3
       3
       -
         postgres:

     

       4
       4
       -
           image: postgres:15

     

       5
       5
       -
           network_mode: host  # Add this line

     

       6
       6
       -
           environment:

     

       7
       7
       -
             POSTGRES_DB: coves_dev

     

       8
       8
       -
             POSTGRES_USER: dev_user

     

       9
       9
       -
             POSTGRES_PASSWORD: dev_password

     

       10
       10
       -
             PGPORT: 5433

     

       11
       11
       -
           volumes:

     

       12
       12
       -
             - ~/Code/Coves/local_dev_data:/var/lib/postgresql/data

-88

internal/db/migrations/002_create_repository_tables.sql

···

       1
       1
       -
       -- +goose Up

     

       2
       2
       -
       -- +goose StatementBegin

     

       3
       3
       -
       

     

       4
       4
       -
       -- Repositories table stores metadata about each user's repository

     

       5
       5
       -
       CREATE TABLE repositories (

     

       6
       6
       -
           did VARCHAR(256) PRIMARY KEY,

     

       7
       7
       -
           head_cid VARCHAR(256) NOT NULL,

     

       8
       8
       -
           revision VARCHAR(64) NOT NULL,

     

       9
       9
       -
           record_count INTEGER NOT NULL DEFAULT 0,

     

       10
       10
       -
           storage_size BIGINT NOT NULL DEFAULT 0,

     

       11
       11
       -
           created_at TIMESTAMP NOT NULL DEFAULT NOW(),

     

       12
       12
       -
           updated_at TIMESTAMP NOT NULL DEFAULT NOW()

     

       13
       13
       -
       );

     

       14
       14
       -
       

     

       15
       15
       -
       CREATE INDEX idx_repositories_updated_at ON repositories(updated_at);

     

       16
       16
       -
       

     

       17
       17
       -
       -- Commits table stores the commit history

     

       18
       18
       -
       CREATE TABLE commits (

     

       19
       19
       -
           cid VARCHAR(256) PRIMARY KEY,

     

       20
       20
       -
           did VARCHAR(256) NOT NULL,

     

       21
       21
       -
           version INTEGER NOT NULL,

     

       22
       22
       -
           prev_cid VARCHAR(256),

     

       23
       23
       -
           data_cid VARCHAR(256) NOT NULL,

     

       24
       24
       -
           revision VARCHAR(64) NOT NULL,

     

       25
       25
       -
           signature BYTEA NOT NULL,

     

       26
       26
       -
           signing_key_id VARCHAR(256) NOT NULL,

     

       27
       27
       -
           created_at TIMESTAMP NOT NULL DEFAULT NOW(),

     

       28
       28
       -
           FOREIGN KEY (did) REFERENCES repositories(did) ON DELETE CASCADE

     

       29
       29
       -
       );

     

       30
       30
       -
       

     

       31
       31
       -
       CREATE INDEX idx_commits_did ON commits(did);

     

       32
       32
       -
       CREATE INDEX idx_commits_created_at ON commits(created_at);

     

       33
       33
       -
       

     

       34
       34
       -
       -- Records table stores record metadata (actual data is in MST)

     

       35
       35
       -
       CREATE TABLE records (

     

       36
       36
       -
           id SERIAL PRIMARY KEY,

     

       37
       37
       -
           did VARCHAR(256) NOT NULL,

     

       38
       38
       -
           uri VARCHAR(512) NOT NULL,

     

       39
       39
       -
           cid VARCHAR(256) NOT NULL,

     

       40
       40
       -
           collection VARCHAR(256) NOT NULL,

     

       41
       41
       -
           record_key VARCHAR(256) NOT NULL,

     

       42
       42
       -
           value BYTEA NOT NULL, -- CBOR-encoded record data

     

       43
       43
       -
           created_at TIMESTAMP NOT NULL DEFAULT NOW(),

     

       44
       44
       -
           updated_at TIMESTAMP NOT NULL DEFAULT NOW(),

     

       45
       45
       -
           UNIQUE(did, collection, record_key),

     

       46
       46
       -
           FOREIGN KEY (did) REFERENCES repositories(did) ON DELETE CASCADE

     

       47
       47
       -
       );

     

       48
       48
       -
       

     

       49
       49
       -
       CREATE INDEX idx_records_did_collection ON records(did, collection);

     

       50
       50
       -
       CREATE INDEX idx_records_uri ON records(uri);

     

       51
       51
       -
       CREATE INDEX idx_records_updated_at ON records(updated_at);

     

       52
       52
       -
       

     

       53
       53
       -
       -- Blobs table stores binary large objects

     

       54
       54
       -
       CREATE TABLE blobs (

     

       55
       55
       -
           cid VARCHAR(256) PRIMARY KEY,

     

       56
       56
       -
           mime_type VARCHAR(256) NOT NULL,

     

       57
       57
       -
           size BIGINT NOT NULL,

     

       58
       58
       -
           ref_count INTEGER NOT NULL DEFAULT 0,

     

       59
       59
       -
           data BYTEA NOT NULL,

     

       60
       60
       -
           created_at TIMESTAMP NOT NULL DEFAULT NOW()

     

       61
       61
       -
       );

     

       62
       62
       -
       

     

       63
       63
       -
       CREATE INDEX idx_blobs_ref_count ON blobs(ref_count);

     

       64
       64
       -
       CREATE INDEX idx_blobs_created_at ON blobs(created_at);

     

       65
       65
       -
       

     

       66
       66
       -
       -- Blob references table tracks which records reference which blobs

     

       67
       67
       -
       CREATE TABLE blob_refs (

     

       68
       68
       -
           id SERIAL PRIMARY KEY,

     

       69
       69
       -
           record_id INTEGER NOT NULL,

     

       70
       70
       -
           blob_cid VARCHAR(256) NOT NULL,

     

       71
       71
       -
           created_at TIMESTAMP NOT NULL DEFAULT NOW(),

     

       72
       72
       -
           FOREIGN KEY (record_id) REFERENCES records(id) ON DELETE CASCADE,

     

       73
       73
       -
           FOREIGN KEY (blob_cid) REFERENCES blobs(cid) ON DELETE RESTRICT,

     

       74
       74
       -
           UNIQUE(record_id, blob_cid)

     

       75
       75
       -
       );

     

       76
       76
       -
       

     

       77
       77
       -
       CREATE INDEX idx_blob_refs_blob_cid ON blob_refs(blob_cid);

     

       78
       78
       -
       

     

       79
       79
       -
       -- +goose StatementEnd

     

       80
       80
       -
       

     

       81
       81
       -
       -- +goose Down

     

       82
       82
       -
       -- +goose StatementBegin

     

       83
       83
       -
       DROP TABLE IF EXISTS blob_refs;

     

       84
       84
       -
       DROP TABLE IF EXISTS blobs;

     

       85
       85
       -
       DROP TABLE IF EXISTS records;

     

       86
       86
       -
       DROP TABLE IF EXISTS commits;

     

       87
       87
       -
       DROP TABLE IF EXISTS repositories;

     

       88
       88
       -
       -- +goose StatementEnd

-65

internal/db/migrations/003_update_for_carstore.sql

···

       1
       1
       -
       -- +goose Up

     

       2
       2
       -
       -- +goose StatementBegin

     

       3
       3
       -
       

     

       4
       4
       -
       -- WARNING: This migration removes blob storage tables. 

     

       5
       5
       -
       -- Ensure all blob data has been migrated to carstore before running this migration.

     

       6
       6
       -
       -- This migration is NOT reversible if blob data exists!

     

       7
       7
       -
       

     

       8
       8
       -
       -- Remove the value column from records table since blocks are now stored in filesystem

     

       9
       9
       -
       ALTER TABLE records DROP COLUMN IF EXISTS value;

     

       10
       10
       -
       

     

       11
       11
       -
       -- Drop blob-related tables since FileCarStore handles block storage

     

       12
       12
       -
       -- WARNING: This will permanently delete all blob data!

     

       13
       13
       -
       DROP TABLE IF EXISTS blob_refs;

     

       14
       14
       -
       DROP TABLE IF EXISTS blobs;

     

       15
       15
       -
       

     

       16
       16
       -
       -- Create block_refs table for garbage collection tracking

     

       17
       17
       -
       CREATE TABLE block_refs (

     

       18
       18
       -
           cid VARCHAR(256) NOT NULL,

     

       19
       19
       -
           did VARCHAR(256) NOT NULL,

     

       20
       20
       -
           created_at TIMESTAMP NOT NULL DEFAULT NOW(),

     

       21
       21
       -
           PRIMARY KEY (cid, did),

     

       22
       22
       -
           FOREIGN KEY (did) REFERENCES repositories(did) ON DELETE CASCADE

     

       23
       23
       -
       );

     

       24
       24
       -
       

     

       25
       25
       -
       CREATE INDEX idx_block_refs_did ON block_refs(did);

     

       26
       26
       -
       CREATE INDEX idx_block_refs_created_at ON block_refs(created_at);

     

       27
       27
       -
       

     

       28
       28
       -
       -- +goose StatementEnd

     

       29
       29
       -
       

     

       30
       30
       -
       -- +goose Down

     

       31
       31
       -
       -- +goose StatementBegin

     

       32
       32
       -
       

     

       33
       33
       -
       -- Recreate the original schema for rollback

     

       34
       34
       -
       DROP TABLE IF EXISTS block_refs;

     

       35
       35
       -
       

     

       36
       36
       -
       -- Add back the value column to records table

     

       37
       37
       -
       ALTER TABLE records ADD COLUMN value BYTEA;

     

       38
       38
       -
       

     

       39
       39
       -
       -- Recreate blobs table

     

       40
       40
       -
       CREATE TABLE blobs (

     

       41
       41
       -
           cid VARCHAR(256) PRIMARY KEY,

     

       42
       42
       -
           mime_type VARCHAR(256) NOT NULL,

     

       43
       43
       -
           size BIGINT NOT NULL,

     

       44
       44
       -
           ref_count INTEGER NOT NULL DEFAULT 0,

     

       45
       45
       -
           data BYTEA NOT NULL,

     

       46
       46
       -
           created_at TIMESTAMP NOT NULL DEFAULT NOW()

     

       47
       47
       -
       );

     

       48
       48
       -
       

     

       49
       49
       -
       CREATE INDEX idx_blobs_ref_count ON blobs(ref_count);

     

       50
       50
       -
       CREATE INDEX idx_blobs_created_at ON blobs(created_at);

     

       51
       51
       -
       

     

       52
       52
       -
       -- Recreate blob_refs table

     

       53
       53
       -
       CREATE TABLE blob_refs (

     

       54
       54
       -
           id SERIAL PRIMARY KEY,

     

       55
       55
       -
           record_id INTEGER NOT NULL,

     

       56
       56
       -
           blob_cid VARCHAR(256) NOT NULL,

     

       57
       57
       -
           created_at TIMESTAMP NOT NULL DEFAULT NOW(),

     

       58
       58
       -
           FOREIGN KEY (record_id) REFERENCES records(id) ON DELETE CASCADE,

     

       59
       59
       -
           FOREIGN KEY (blob_cid) REFERENCES blobs(cid) ON DELETE RESTRICT,

     

       60
       60
       -
           UNIQUE(record_id, blob_cid)

     

       61
       61
       -
       );

     

       62
       62
       -
       

     

       63
       63
       -
       CREATE INDEX idx_blob_refs_blob_cid ON blob_refs(blob_cid);

     

       64
       64
       -
       

     

       65
       65
       -
       -- +goose StatementEnd

-20

internal/db/migrations/004_remove_block_refs_for_indigo.sql

···

       1
       1
       -
       -- +goose Up

     

       2
       2
       -
       -- +goose StatementBegin

     

       3
       3
       -
       -- Drop our block_refs table since Indigo's carstore will create its own

     

       4
       4
       -
       DROP TABLE IF EXISTS block_refs;

     

       5
       5
       -
       -- +goose StatementEnd

     

       6
       6
       -
       

     

       7
       7
       -
       -- +goose Down

     

       8
       8
       -
       -- +goose StatementBegin

     

       9
       9
       -
       -- Recreate block_refs table

     

       10
       10
       -
       CREATE TABLE block_refs (

     

       11
       11
       -
           cid VARCHAR(256) NOT NULL,

     

       12
       12
       -
           did VARCHAR(256) NOT NULL,

     

       13
       13
       -
           created_at TIMESTAMP NOT NULL DEFAULT NOW(),

     

       14
       14
       -
           PRIMARY KEY (cid, did),

     

       15
       15
       -
           FOREIGN KEY (did) REFERENCES repositories(did) ON DELETE CASCADE

     

       16
       16
       -
       );

     

       17
       17
       -
       

     

       18
       18
       -
       CREATE INDEX idx_block_refs_did ON block_refs(did);

     

       19
       19
       -
       CREATE INDEX idx_block_refs_created_at ON block_refs(created_at);

     

       20
       20
       -
       -- +goose StatementEnd

-465

internal/db/postgres/repository_repo.go

···

       1
       1
       -
       package postgres

     

       2
       2
       -
       

     

       3
       3
       -
       import (

     

       4
       4
       -
       	"database/sql"

     

       5
       5
       -
       	"fmt"

     

       6
       6
       -
       	"time"

     

       7
       7
       -
       

     

       8
       8
       -
       	"Coves/internal/core/repository"

     

       9
       9
       -
       	"github.com/ipfs/go-cid"

     

       10
       10
       -
       	"github.com/lib/pq"

     

       11
       11
       -
       )

     

       12
       12
       -
       

     

       13
       13
       -
       // RepositoryRepo implements repository.RepositoryRepository using PostgreSQL

     

       14
       14
       -
       type RepositoryRepo struct {

     

       15
       15
       -
       	db *sql.DB

     

       16
       16
       -
       }

     

       17
       17
       -
       

     

       18
       18
       -
       // NewRepositoryRepo creates a new PostgreSQL repository implementation

     

       19
       19
       -
       func NewRepositoryRepo(db *sql.DB) *RepositoryRepo {

     

       20
       20
       -
       	return &RepositoryRepo{db: db}

     

       21
       21
       -
       }

     

       22
       22
       -
       

     

       23
       23
       -
       // Repository operations

     

       24
       24
       -
       

     

       25
       25
       -
       func (r *RepositoryRepo) Create(repo *repository.Repository) error {

     

       26
       26
       -
       	query := `

     

       27
       27
       -
       		INSERT INTO repositories (did, head_cid, revision, record_count, storage_size, created_at, updated_at)

     

       28
       28
       -
       		VALUES ($1, $2, $3, $4, $5, $6, $7)`

     

       29
       29
       -
       	

     

       30
       30
       -
       	_, err := r.db.Exec(query,

     

       31
       31
       -
       		repo.DID,

     

       32
       32
       -
       		repo.HeadCID.String(),

     

       33
       33
       -
       		repo.Revision,

     

       34
       34
       -
       		repo.RecordCount,

     

       35
       35
       -
       		repo.StorageSize,

     

       36
       36
       -
       		repo.CreatedAt,

     

       37
       37
       -
       		repo.UpdatedAt,

     

       38
       38
       -
       	)

     

       39
       39
       -
       	if err != nil {

     

       40
       40
       -
       		return fmt.Errorf("failed to create repository: %w", err)

     

       41
       41
       -
       	}

     

       42
       42
       -
       	

     

       43
       43
       -
       	return nil

     

       44
       44
       -
       }

     

       45
       45
       -
       

     

       46
       46
       -
       func (r *RepositoryRepo) GetByDID(did string) (*repository.Repository, error) {

     

       47
       47
       -
       	query := `

     

       48
       48
       -
       		SELECT did, head_cid, revision, record_count, storage_size, created_at, updated_at

     

       49
       49
       -
       		FROM repositories

     

       50
       50
       -
       		WHERE did = $1`

     

       51
       51
       -
       	

     

       52
       52
       -
       	var repo repository.Repository

     

       53
       53
       -
       	var headCIDStr string

     

       54
       54
       -
       	

     

       55
       55
       -
       	err := r.db.QueryRow(query, did).Scan(

     

       56
       56
       -
       		&repo.DID,

     

       57
       57
       -
       		&headCIDStr,

     

       58
       58
       -
       		&repo.Revision,

     

       59
       59
       -
       		&repo.RecordCount,

     

       60
       60
       -
       		&repo.StorageSize,

     

       61
       61
       -
       		&repo.CreatedAt,

     

       62
       62
       -
       		&repo.UpdatedAt,

     

       63
       63
       -
       	)

     

       64
       64
       -
       	if err == sql.ErrNoRows {

     

       65
       65
       -
       		return nil, nil

     

       66
       66
       -
       	}

     

       67
       67
       -
       	if err != nil {

     

       68
       68
       -
       		return nil, fmt.Errorf("failed to get repository: %w", err)

     

       69
       69
       -
       	}

     

       70
       70
       -
       	

     

       71
       71
       -
       	repo.HeadCID, err = cid.Parse(headCIDStr)

     

       72
       72
       -
       	if err != nil {

     

       73
       73
       -
       		return nil, fmt.Errorf("failed to parse head CID: %w", err)

     

       74
       74
       -
       	}

     

       75
       75
       -
       	

     

       76
       76
       -
       	return &repo, nil

     

       77
       77
       -
       }

     

       78
       78
       -
       

     

       79
       79
       -
       func (r *RepositoryRepo) Update(repo *repository.Repository) error {

     

       80
       80
       -
       	query := `

     

       81
       81
       -
       		UPDATE repositories

     

       82
       82
       -
       		SET head_cid = $2, revision = $3, record_count = $4, storage_size = $5, updated_at = $6

     

       83
       83
       -
       		WHERE did = $1`

     

       84
       84
       -
       	

     

       85
       85
       -
       	result, err := r.db.Exec(query,

     

       86
       86
       -
       		repo.DID,

     

       87
       87
       -
       		repo.HeadCID.String(),

     

       88
       88
       -
       		repo.Revision,

     

       89
       89
       -
       		repo.RecordCount,

     

       90
       90
       -
       		repo.StorageSize,

     

       91
       91
       -
       		time.Now(),

     

       92
       92
       -
       	)

     

       93
       93
       -
       	if err != nil {

     

       94
       94
       -
       		return fmt.Errorf("failed to update repository: %w", err)

     

       95
       95
       -
       	}

     

       96
       96
       -
       	

     

       97
       97
       -
       	rowsAffected, err := result.RowsAffected()

     

       98
       98
       -
       	if err != nil {

     

       99
       99
       -
       		return fmt.Errorf("failed to get rows affected: %w", err)

     

       100
       100
       -
       	}

     

       101
       101
       -
       	if rowsAffected == 0 {

     

       102
       102
       -
       		return fmt.Errorf("repository not found: %s", repo.DID)

     

       103
       103
       -
       	}

     

       104
       104
       -
       	

     

       105
       105
       -
       	return nil

     

       106
       106
       -
       }

     

       107
       107
       -
       

     

       108
       108
       -
       func (r *RepositoryRepo) Delete(did string) error {

     

       109
       109
       -
       	query := `DELETE FROM repositories WHERE did = $1`

     

       110
       110
       -
       	

     

       111
       111
       -
       	result, err := r.db.Exec(query, did)

     

       112
       112
       -
       	if err != nil {

     

       113
       113
       -
       		return fmt.Errorf("failed to delete repository: %w", err)

     

       114
       114
       -
       	}

     

       115
       115
       -
       	

     

       116
       116
       -
       	rowsAffected, err := result.RowsAffected()

     

       117
       117
       -
       	if err != nil {

     

       118
       118
       -
       		return fmt.Errorf("failed to get rows affected: %w", err)

     

       119
       119
       -
       	}

     

       120
       120
       -
       	if rowsAffected == 0 {

     

       121
       121
       -
       		return fmt.Errorf("repository not found: %s", did)

     

       122
       122
       -
       	}

     

       123
       123
       -
       	

     

       124
       124
       -
       	return nil

     

       125
       125
       -
       }

     

       126
       126
       -
       

     

       127
       127
       -
       // Commit operations

     

       128
       128
       -
       

     

       129
       129
       -
       func (r *RepositoryRepo) CreateCommit(commit *repository.Commit) error {

     

       130
       130
       -
       	query := `

     

       131
       131
       -
       		INSERT INTO commits (cid, did, version, prev_cid, data_cid, revision, signature, signing_key_id, created_at)

     

       132
       132
       -
       		VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)`

     

       133
       133
       -
       	

     

       134
       134
       -
       	var prevCID *string

     

       135
       135
       -
       	if commit.PrevCID != nil {

     

       136
       136
       -
       		s := commit.PrevCID.String()

     

       137
       137
       -
       		prevCID = &s

     

       138
       138
       -
       	}

     

       139
       139
       -
       	

     

       140
       140
       -
       	_, err := r.db.Exec(query,

     

       141
       141
       -
       		commit.CID.String(),

     

       142
       142
       -
       		commit.DID,

     

       143
       143
       -
       		commit.Version,

     

       144
       144
       -
       		prevCID,

     

       145
       145
       -
       		commit.DataCID.String(),

     

       146
       146
       -
       		commit.Revision,

     

       147
       147
       -
       		commit.Signature,

     

       148
       148
       -
       		commit.SigningKeyID,

     

       149
       149
       -
       		commit.CreatedAt,

     

       150
       150
       -
       	)

     

       151
       151
       -
       	if err != nil {

     

       152
       152
       -
       		return fmt.Errorf("failed to create commit: %w", err)

     

       153
       153
       -
       	}

     

       154
       154
       -
       	

     

       155
       155
       -
       	return nil

     

       156
       156
       -
       }

     

       157
       157
       -
       

     

       158
       158
       -
       func (r *RepositoryRepo) GetCommit(did string, commitCID cid.Cid) (*repository.Commit, error) {

     

       159
       159
       -
       	query := `

     

       160
       160
       -
       		SELECT cid, did, version, prev_cid, data_cid, revision, signature, signing_key_id, created_at

     

       161
       161
       -
       		FROM commits

     

       162
       162
       -
       		WHERE did = $1 AND cid = $2`

     

       163
       163
       -
       	

     

       164
       164
       -
       	var commit repository.Commit

     

       165
       165
       -
       	var cidStr, dataCIDStr string

     

       166
       166
       -
       	var prevCIDStr sql.NullString

     

       167
       167
       -
       	

     

       168
       168
       -
       	err := r.db.QueryRow(query, did, commitCID.String()).Scan(

     

       169
       169
       -
       		&cidStr,

     

       170
       170
       -
       		&commit.DID,

     

       171
       171
       -
       		&commit.Version,

     

       172
       172
       -
       		&prevCIDStr,

     

       173
       173
       -
       		&dataCIDStr,

     

       174
       174
       -
       		&commit.Revision,

     

       175
       175
       -
       		&commit.Signature,

     

       176
       176
       -
       		&commit.SigningKeyID,

     

       177
       177
       -
       		&commit.CreatedAt,

     

       178
       178
       -
       	)

     

       179
       179
       -
       	if err == sql.ErrNoRows {

     

       180
       180
       -
       		return nil, nil

     

       181
       181
       -
       	}

     

       182
       182
       -
       	if err != nil {

     

       183
       183
       -
       		return nil, fmt.Errorf("failed to get commit: %w", err)

     

       184
       184
       -
       	}

     

       185
       185
       -
       	

     

       186
       186
       -
       	commit.CID, err = cid.Parse(cidStr)

     

       187
       187
       -
       	if err != nil {

     

       188
       188
       -
       		return nil, fmt.Errorf("failed to parse commit CID: %w", err)

     

       189
       189
       -
       	}

     

       190
       190
       -
       	

     

       191
       191
       -
       	commit.DataCID, err = cid.Parse(dataCIDStr)

     

       192
       192
       -
       	if err != nil {

     

       193
       193
       -
       		return nil, fmt.Errorf("failed to parse data CID: %w", err)

     

       194
       194
       -
       	}

     

       195
       195
       -
       	

     

       196
       196
       -
       	if prevCIDStr.Valid {

     

       197
       197
       -
       		prevCID, err := cid.Parse(prevCIDStr.String)

     

       198
       198
       -
       		if err != nil {

     

       199
       199
       -
       			return nil, fmt.Errorf("failed to parse prev CID: %w", err)

     

       200
       200
       -
       		}

     

       201
       201
       -
       		commit.PrevCID = &prevCID

     

       202
       202
       -
       	}

     

       203
       203
       -
       	

     

       204
       204
       -
       	return &commit, nil

     

       205
       205
       -
       }

     

       206
       206
       -
       

     

       207
       207
       -
       func (r *RepositoryRepo) GetLatestCommit(did string) (*repository.Commit, error) {

     

       208
       208
       -
       	query := `

     

       209
       209
       -
       		SELECT cid, did, version, prev_cid, data_cid, revision, signature, signing_key_id, created_at

     

       210
       210
       -
       		FROM commits

     

       211
       211
       -
       		WHERE did = $1

     

       212
       212
       -
       		ORDER BY created_at DESC

     

       213
       213
       -
       		LIMIT 1`

     

       214
       214
       -
       	

     

       215
       215
       -
       	var commit repository.Commit

     

       216
       216
       -
       	var cidStr, dataCIDStr string

     

       217
       217
       -
       	var prevCIDStr sql.NullString

     

       218
       218
       -
       	

     

       219
       219
       -
       	err := r.db.QueryRow(query, did).Scan(

     

       220
       220
       -
       		&cidStr,

     

       221
       221
       -
       		&commit.DID,

     

       222
       222
       -
       		&commit.Version,

     

       223
       223
       -
       		&prevCIDStr,

     

       224
       224
       -
       		&dataCIDStr,

     

       225
       225
       -
       		&commit.Revision,

     

       226
       226
       -
       		&commit.Signature,

     

       227
       227
       -
       		&commit.SigningKeyID,

     

       228
       228
       -
       		&commit.CreatedAt,

     

       229
       229
       -
       	)

     

       230
       230
       -
       	if err == sql.ErrNoRows {

     

       231
       231
       -
       		return nil, nil

     

       232
       232
       -
       	}

     

       233
       233
       -
       	if err != nil {

     

       234
       234
       -
       		return nil, fmt.Errorf("failed to get latest commit: %w", err)

     

       235
       235
       -
       	}

     

       236
       236
       -
       	

     

       237
       237
       -
       	commit.CID, err = cid.Parse(cidStr)

     

       238
       238
       -
       	if err != nil {

     

       239
       239
       -
       		return nil, fmt.Errorf("failed to parse commit CID: %w", err)

     

       240
       240
       -
       	}

     

       241
       241
       -
       	

     

       242
       242
       -
       	commit.DataCID, err = cid.Parse(dataCIDStr)

     

       243
       243
       -
       	if err != nil {

     

       244
       244
       -
       		return nil, fmt.Errorf("failed to parse data CID: %w", err)

     

       245
       245
       -
       	}

     

       246
       246
       -
       	

     

       247
       247
       -
       	if prevCIDStr.Valid {

     

       248
       248
       -
       		prevCID, err := cid.Parse(prevCIDStr.String)

     

       249
       249
       -
       		if err != nil {

     

       250
       250
       -
       			return nil, fmt.Errorf("failed to parse prev CID: %w", err)

     

       251
       251
       -
       		}

     

       252
       252
       -
       		commit.PrevCID = &prevCID

     

       253
       253
       -
       	}

     

       254
       254
       -
       	

     

       255
       255
       -
       	return &commit, nil

     

       256
       256
       -
       }

     

       257
       257
       -
       

     

       258
       258
       -
       func (r *RepositoryRepo) ListCommits(did string, limit int, offset int) ([]*repository.Commit, error) {

     

       259
       259
       -
       	query := `

     

       260
       260
       -
       		SELECT cid, did, version, prev_cid, data_cid, revision, signature, signing_key_id, created_at

     

       261
       261
       -
       		FROM commits

     

       262
       262
       -
       		WHERE did = $1

     

       263
       263
       -
       		ORDER BY created_at DESC

     

       264
       264
       -
       		LIMIT $2 OFFSET $3`

     

       265
       265
       -
       	

     

       266
       266
       -
       	rows, err := r.db.Query(query, did, limit, offset)

     

       267
       267
       -
       	if err != nil {

     

       268
       268
       -
       		return nil, fmt.Errorf("failed to list commits: %w", err)

     

       269
       269
       -
       	}

     

       270
       270
       -
       	defer rows.Close()

     

       271
       271
       -
       	

     

       272
       272
       -
       	var commits []*repository.Commit

     

       273
       273
       -
       	for rows.Next() {

     

       274
       274
       -
       		var commit repository.Commit

     

       275
       275
       -
       		var cidStr, dataCIDStr string

     

       276
       276
       -
       		var prevCIDStr sql.NullString

     

       277
       277
       -
       		

     

       278
       278
       -
       		err := rows.Scan(

     

       279
       279
       -
       			&cidStr,

     

       280
       280
       -
       			&commit.DID,

     

       281
       281
       -
       			&commit.Version,

     

       282
       282
       -
       			&prevCIDStr,

     

       283
       283
       -
       			&dataCIDStr,

     

       284
       284
       -
       			&commit.Revision,

     

       285
       285
       -
       			&commit.Signature,

     

       286
       286
       -
       			&commit.SigningKeyID,

     

       287
       287
       -
       			&commit.CreatedAt,

     

       288
       288
       -
       		)

     

       289
       289
       -
       		if err != nil {

     

       290
       290
       -
       			return nil, fmt.Errorf("failed to scan commit: %w", err)

     

       291
       291
       -
       		}

     

       292
       292
       -
       		

     

       293
       293
       -
       		commit.CID, err = cid.Parse(cidStr)

     

       294
       294
       -
       		if err != nil {

     

       295
       295
       -
       			return nil, fmt.Errorf("failed to parse commit CID: %w", err)

     

       296
       296
       -
       		}

     

       297
       297
       -
       		

     

       298
       298
       -
       		commit.DataCID, err = cid.Parse(dataCIDStr)

     

       299
       299
       -
       		if err != nil {

     

       300
       300
       -
       			return nil, fmt.Errorf("failed to parse data CID: %w", err)

     

       301
       301
       -
       		}

     

       302
       302
       -
       		

     

       303
       303
       -
       		if prevCIDStr.Valid {

     

       304
       304
       -
       			prevCID, err := cid.Parse(prevCIDStr.String)

     

       305
       305
       -
       			if err != nil {

     

       306
       306
       -
       				return nil, fmt.Errorf("failed to parse prev CID: %w", err)

     

       307
       307
       -
       			}

     

       308
       308
       -
       			commit.PrevCID = &prevCID

     

       309
       309
       -
       		}

     

       310
       310
       -
       		

     

       311
       311
       -
       		commits = append(commits, &commit)

     

       312
       312
       -
       	}

     

       313
       313
       -
       	

     

       314
       314
       -
       	return commits, nil

     

       315
       315
       -
       }

     

       316
       316
       -
       

     

       317
       317
       -
       // Record operations

     

       318
       318
       -
       

     

       319
       319
       -
       func (r *RepositoryRepo) CreateRecord(record *repository.Record) error {

     

       320
       320
       -
       	query := `

     

       321
       321
       -
       		INSERT INTO records (did, uri, cid, collection, record_key, created_at, updated_at)

     

       322
       322
       -
       		VALUES ($1, $2, $3, $4, $5, $6, $7)`

     

       323
       323
       -
       	

     

       324
       324
       -
       	_, err := r.db.Exec(query,

     

       325
       325
       -
       		record.URI[:len("at://")+len(record.URI[len("at://"):])-len(record.Collection)-len(record.RecordKey)-2], // Extract DID from URI

     

       326
       326
       -
       		record.URI,

     

       327
       327
       -
       		record.CID.String(),

     

       328
       328
       -
       		record.Collection,

     

       329
       329
       -
       		record.RecordKey,

     

       330
       330
       -
       		record.CreatedAt,

     

       331
       331
       -
       		record.UpdatedAt,

     

       332
       332
       -
       	)

     

       333
       333
       -
       	if err != nil {

     

       334
       334
       -
       		if pqErr, ok := err.(*pq.Error); ok && pqErr.Code == "23505" { // unique_violation

     

       335
       335
       -
       			return fmt.Errorf("record already exists: %s", record.URI)

     

       336
       336
       -
       		}

     

       337
       337
       -
       		return fmt.Errorf("failed to create record: %w", err)

     

       338
       338
       -
       	}

     

       339
       339
       -
       	

     

       340
       340
       -
       	return nil

     

       341
       341
       -
       }

     

       342
       342
       -
       

     

       343
       343
       -
       func (r *RepositoryRepo) GetRecord(did string, collection string, recordKey string) (*repository.Record, error) {

     

       344
       344
       -
       	query := `

     

       345
       345
       -
       		SELECT uri, cid, collection, record_key, created_at, updated_at

     

       346
       346
       -
       		FROM records

     

       347
       347
       -
       		WHERE did = $1 AND collection = $2 AND record_key = $3`

     

       348
       348
       -
       	

     

       349
       349
       -
       	var record repository.Record

     

       350
       350
       -
       	var cidStr string

     

       351
       351
       -
       	

     

       352
       352
       -
       	err := r.db.QueryRow(query, did, collection, recordKey).Scan(

     

       353
       353
       -
       		&record.URI,

     

       354
       354
       -
       		&cidStr,

     

       355
       355
       -
       		&record.Collection,

     

       356
       356
       -
       		&record.RecordKey,

     

       357
       357
       -
       		&record.CreatedAt,

     

       358
       358
       -
       		&record.UpdatedAt,

     

       359
       359
       -
       	)

     

       360
       360
       -
       	if err == sql.ErrNoRows {

     

       361
       361
       -
       		return nil, nil

     

       362
       362
       -
       	}

     

       363
       363
       -
       	if err != nil {

     

       364
       364
       -
       		return nil, fmt.Errorf("failed to get record: %w", err)

     

       365
       365
       -
       	}

     

       366
       366
       -
       	

     

       367
       367
       -
       	record.CID, err = cid.Parse(cidStr)

     

       368
       368
       -
       	if err != nil {

     

       369
       369
       -
       		return nil, fmt.Errorf("failed to parse record CID: %w", err)

     

       370
       370
       -
       	}

     

       371
       371
       -
       	

     

       372
       372
       -
       	return &record, nil

     

       373
       373
       -
       }

     

       374
       374
       -
       

     

       375
       375
       -
       func (r *RepositoryRepo) UpdateRecord(record *repository.Record) error {

     

       376
       376
       -
       	did := record.URI[:len("at://")+len(record.URI[len("at://"):])-len(record.Collection)-len(record.RecordKey)-2]

     

       377
       377
       -
       	

     

       378
       378
       -
       	query := `

     

       379
       379
       -
       		UPDATE records

     

       380
       380
       -
       		SET cid = $4, updated_at = $5

     

       381
       381
       -
       		WHERE did = $1 AND collection = $2 AND record_key = $3`

     

       382
       382
       -
       	

     

       383
       383
       -
       	result, err := r.db.Exec(query,

     

       384
       384
       -
       		did,

     

       385
       385
       -
       		record.Collection,

     

       386
       386
       -
       		record.RecordKey,

     

       387
       387
       -
       		record.CID.String(),

     

       388
       388
       -
       		time.Now(),

     

       389
       389
       -
       	)

     

       390
       390
       -
       	if err != nil {

     

       391
       391
       -
       		return fmt.Errorf("failed to update record: %w", err)

     

       392
       392
       -
       	}

     

       393
       393
       -
       	

     

       394
       394
       -
       	rowsAffected, err := result.RowsAffected()

     

       395
       395
       -
       	if err != nil {

     

       396
       396
       -
       		return fmt.Errorf("failed to get rows affected: %w", err)

     

       397
       397
       -
       	}

     

       398
       398
       -
       	if rowsAffected == 0 {

     

       399
       399
       -
       		return fmt.Errorf("record not found: %s", record.URI)

     

       400
       400
       -
       	}

     

       401
       401
       -
       	

     

       402
       402
       -
       	return nil

     

       403
       403
       -
       }

     

       404
       404
       -
       

     

       405
       405
       -
       func (r *RepositoryRepo) DeleteRecord(did string, collection string, recordKey string) error {

     

       406
       406
       -
       	query := `DELETE FROM records WHERE did = $1 AND collection = $2 AND record_key = $3`

     

       407
       407
       -
       	

     

       408
       408
       -
       	result, err := r.db.Exec(query, did, collection, recordKey)

     

       409
       409
       -
       	if err != nil {

     

       410
       410
       -
       		return fmt.Errorf("failed to delete record: %w", err)

     

       411
       411
       -
       	}

     

       412
       412
       -
       	

     

       413
       413
       -
       	rowsAffected, err := result.RowsAffected()

     

       414
       414
       -
       	if err != nil {

     

       415
       415
       -
       		return fmt.Errorf("failed to get rows affected: %w", err)

     

       416
       416
       -
       	}

     

       417
       417
       -
       	if rowsAffected == 0 {

     

       418
       418
       -
       		return fmt.Errorf("record not found")

     

       419
       419
       -
       	}

     

       420
       420
       -
       	

     

       421
       421
       -
       	return nil

     

       422
       422
       -
       }

     

       423
       423
       -
       

     

       424
       424
       -
       func (r *RepositoryRepo) ListRecords(did string, collection string, limit int, offset int) ([]*repository.Record, error) {

     

       425
       425
       -
       	query := `

     

       426
       426
       -
       		SELECT uri, cid, collection, record_key, created_at, updated_at

     

       427
       427
       -
       		FROM records

     

       428
       428
       -
       		WHERE did = $1 AND collection = $2

     

       429
       429
       -
       		ORDER BY created_at DESC

     

       430
       430
       -
       		LIMIT $3 OFFSET $4`

     

       431
       431
       -
       	

     

       432
       432
       -
       	rows, err := r.db.Query(query, did, collection, limit, offset)

     

       433
       433
       -
       	if err != nil {

     

       434
       434
       -
       		return nil, fmt.Errorf("failed to list records: %w", err)

     

       435
       435
       -
       	}

     

       436
       436
       -
       	defer rows.Close()

     

       437
       437
       -
       	

     

       438
       438
       -
       	var records []*repository.Record

     

       439
       439
       -
       	for rows.Next() {

     

       440
       440
       -
       		var record repository.Record

     

       441
       441
       -
       		var cidStr string

     

       442
       442
       -
       		

     

       443
       443
       -
       		err := rows.Scan(

     

       444
       444
       -
       			&record.URI,

     

       445
       445
       -
       			&cidStr,

     

       446
       446
       -
       			&record.Collection,

     

       447
       447
       -
       			&record.RecordKey,

     

       448
       448
       -
       			&record.CreatedAt,

     

       449
       449
       -
       			&record.UpdatedAt,

     

       450
       450
       -
       		)

     

       451
       451
       -
       		if err != nil {

     

       452
       452
       -
       			return nil, fmt.Errorf("failed to scan record: %w", err)

     

       453
       453
       -
       		}

     

       454
       454
       -
       		

     

       455
       455
       -
       		record.CID, err = cid.Parse(cidStr)

     

       456
       456
       -
       		if err != nil {

     

       457
       457
       -
       			return nil, fmt.Errorf("failed to parse record CID: %w", err)

     

       458
       458
       -
       		}

     

       459
       459
       -
       		

     

       460
       460
       -
       		records = append(records, &record)

     

       461
       461
       -
       	}

     

       462
       462
       -
       	

     

       463
       463
       -
       	return records, nil

     

       464
       464
       -
       }

     

       465
       465
       -

-84

internal/db/test_db_compose/README.md

···

       1
       1
       -
       # Test Database Setup

     

       2
       2
       -
       

     

       3
       3
       -
       This directory contains the Docker Compose configuration for the Coves test database.

     

       4
       4
       -
       

     

       5
       5
       -
       ## Overview

     

       6
       6
       -
       

     

       7
       7
       -
       The test database is a PostgreSQL instance specifically for running automated tests. It's completely isolated from development and production databases.

     

       8
       8
       -
       

     

       9
       9
       -
       ### Configuration

     

       10
       10
       -
       

     

       11
       11
       -
       - **Port**: 5434 (different from dev: 5433, prod: 5432)

     

       12
       12
       -
       - **Database**: coves_test

     

       13
       13
       -
       - **User**: test_user

     

       14
       14
       -
       - **Password**: test_password

     

       15
       15
       -
       - **Data Volume**: ~/Code/Coves/test_db_data

     

       16
       16
       -
       

     

       17
       17
       -
       ## Usage

     

       18
       18
       -
       

     

       19
       19
       -
       ### Starting the Test Database

     

       20
       20
       -
       

     

       21
       21
       -
       ```bash

     

       22
       22
       -
       cd internal/db/test_db_compose

     

       23
       23
       -
       ./start-test-db.sh

     

       24
       24
       -
       ```

     

       25
       25
       -
       

     

       26
       26
       -
       This will:

     

       27
       27
       -
       1. Start the PostgreSQL container

     

       28
       28
       -
       2. Wait for it to be ready

     

       29
       29
       -
       3. Display the connection string

     

       30
       30
       -
       

     

       31
       31
       -
       ### Running Tests

     

       32
       32
       -
       

     

       33
       33
       -
       Once the database is running, you can run tests with:

     

       34
       34
       -
       

     

       35
       35
       -
       ```bash

     

       36
       36
       -
       TEST_DATABASE_URL=postgres://test_user:test_password@localhost:5434/coves_test?sslmode=disable go test -v ./...

     

       37
       37
       -
       ```

     

       38
       38
       -
       

     

       39
       39
       -
       Or set the environment variable:

     

       40
       40
       -
       

     

       41
       41
       -
       ```bash

     

       42
       42
       -
       export TEST_DATABASE_URL=postgres://test_user:test_password@localhost:5434/coves_test?sslmode=disable

     

       43
       43
       -
       go test -v ./...

     

       44
       44
       -
       ```

     

       45
       45
       -
       

     

       46
       46
       -
       ### Stopping the Test Database

     

       47
       47
       -
       

     

       48
       48
       -
       ```bash

     

       49
       49
       -
       ./stop-test-db.sh

     

       50
       50
       -
       ```

     

       51
       51
       -
       

     

       52
       52
       -
       ### Resetting Test Data

     

       53
       53
       -
       

     

       54
       54
       -
       To completely reset the test database (removes all data):

     

       55
       55
       -
       

     

       56
       56
       -
       ```bash

     

       57
       57
       -
       ./reset-test-db.sh

     

       58
       58
       -
       ```

     

       59
       59
       -
       

     

       60
       60
       -
       ## Test Isolation

     

       61
       61
       -
       

     

       62
       62
       -
       The test database is isolated from other environments:

     

       63
       63
       -
       

     

       64
       64
       -
       | Environment | Port | Database Name | User |

     

       65
       65
       -
       |------------|------|--------------|------|

     

       66
       66
       -
       | Test | 5434 | coves_test | test_user |

     

       67
       67
       -
       | Development | 5433 | coves_dev | dev_user |

     

       68
       68
       -
       | Production | 5432 | coves | (varies) |

     

       69
       69
       -
       

     

       70
       70
       -
       ## What Gets Tested

     

       71
       71
       -
       

     

       72
       72
       -
       When tests run against this database, they will:

     

       73
       73
       -
       

     

       74
       74
       -
       1. Run all migrations from `internal/db/migrations/`

     

       75
       75
       -
       2. Create Indigo carstore tables (via GORM auto-migration)

     

       76
       76
       -
       3. Test the full integration including:

     

       77
       77
       -
          - Repository CRUD operations

     

       78
       78
       -
          - CAR file metadata storage

     

       79
       79
       -
          - User DID to UID mapping

     

       80
       80
       -
          - Carstore operations

     

       81
       81
       -
       

     

       82
       82
       -
       ## CI/CD Integration

     

       83
       83
       -
       

     

       84
       84
       -
       For CI/CD pipelines, you can use the same Docker Compose setup or connect to a dedicated test database instance.

-19

internal/db/test_db_compose/docker-compose.yml

···

       1
       1
       -
       # Test Database Docker Compose Configuration

     

       2
       2
       -
       # This database is specifically for running tests and is isolated from dev/prod

     

       3
       3
       -
       services:

     

       4
       4
       -
         postgres_test:

     

       5
       5
       -
           image: postgres:15

     

       6
       6
       -
           container_name: coves_test_db

     

       7
       7
       -
           network_mode: host

     

       8
       8
       -
           environment:

     

       9
       9
       -
             POSTGRES_DB: coves_test

     

       10
       10
       -
             POSTGRES_USER: test_user

     

       11
       11
       -
             POSTGRES_PASSWORD: test_password

     

       12
       12
       -
             PGPORT: 5434  # Different port from dev (5433) and prod (5432)

     

       13
       13
       -
           volumes:

     

       14
       14
       -
             - ~/Code/Coves/test_db_data:/var/lib/postgresql/data

     

       15
       15
       -
           healthcheck:

     

       16
       16
       -
             test: ["CMD-SHELL", "pg_isready -U test_user -d coves_test -p 5434"]

     

       17
       17
       -
             interval: 5s

     

       18
       18
       -
             timeout: 5s

     

       19
       19
       -
             retries: 5

-15

internal/db/test_db_compose/reset-test-db.sh

···

       1
       1
       -
       #!/bin/bash

     

       2
       2
       -
       # Reset the test database by removing all data

     

       3
       3
       -
       

     

       4
       4
       -
       echo "WARNING: This will delete all test database data!"

     

       5
       5
       -
       echo "Press Ctrl+C to cancel, or Enter to continue..."

     

       6
       6
       -
       read

     

       7
       7
       -
       

     

       8
       8
       -
       echo "Stopping test database..."

     

       9
       9
       -
       docker-compose -f docker-compose.yml down

     

       10
       10
       -
       

     

       11
       11
       -
       echo "Removing test data volume..."

     

       12
       12
       -
       rm -rf ~/Code/Coves/test_db_data

     

       13
       13
       -
       

     

       14
       14
       -
       echo "Starting fresh test database..."

     

       15
       15
       -
       ./start-test-db.sh

-25

internal/db/test_db_compose/start-test-db.sh

···

       1
       1
       -
       #!/bin/bash

     

       2
       2
       -
       # Start the test database

     

       3
       3
       -
       

     

       4
       4
       -
       echo "Starting Coves test database on port 5434..."

     

       5
       5
       -
       docker-compose -f docker-compose.yml up -d

     

       6
       6
       -
       

     

       7
       7
       -
       # Wait for database to be ready

     

       8
       8
       -
       echo "Waiting for database to be ready..."

     

       9
       9
       -
       for i in {1..30}; do

     

       10
       10
       -
           if docker-compose -f docker-compose.yml exec -T postgres_test pg_isready -U test_user -d coves_test -p 5434 &>/dev/null; then

     

       11
       11
       -
               echo "Test database is ready!"

     

       12
       12
       -
               echo ""

     

       13
       13
       -
               echo "Connection string:"

     

       14
       14
       -
               echo "TEST_DATABASE_URL=postgres://test_user:test_password@localhost:5434/coves_test?sslmode=disable"

     

       15
       15
       -
               echo ""

     

       16
       16
       -
               echo "To run tests:"

     

       17
       17
       -
               echo "TEST_DATABASE_URL=postgres://test_user:test_password@localhost:5434/coves_test?sslmode=disable go test -v ./..."

     

       18
       18
       -
               exit 0

     

       19
       19
       -
           fi

     

       20
       20
       -
           echo -n "."

     

       21
       21
       -
           sleep 1

     

       22
       22
       -
       done

     

       23
       23
       -
       

     

       24
       24
       -
       echo "Failed to start test database"

     

       25
       25
       -
       exit 1

-7

internal/db/test_db_compose/stop-test-db.sh

···

       1
       1
       -
       #!/bin/bash

     

       2
       2
       -
       # Stop the test database

     

       3
       3
       -
       

     

       4
       4
       -
       echo "Stopping Coves test database..."

     

       5
       5
       -
       docker-compose -f docker-compose.yml down

     

       6
       6
       -
       

     

       7
       7
       -
       echo "Test database stopped."

-103

tests/integration/repository_test.go

···

       1
       1
       -
       package integration_test

     

       2
       2
       -
       

     

       3
       3
       -
       import (

     

       4
       4
       -
       	"os"

     

       5
       5
       -
       	"testing"

     

       6
       6
       -
       

     

       7
       7
       -
       	"Coves/internal/atproto/carstore"

     

       8
       8
       -
       	"Coves/internal/core/repository"

     

       9
       9
       -
       	"Coves/internal/db/postgres"

     

       10
       10
       -
       	"database/sql"

     

       11
       11
       -
       	_ "github.com/lib/pq"

     

       12
       12
       -
       	"github.com/pressly/goose/v3"

     

       13
       13
       -
       	postgresDriver "gorm.io/driver/postgres"

     

       14
       14
       -
       	"gorm.io/gorm"

     

       15
       15
       -
       )

     

       16
       16
       -
       

     

       17
       17
       -
       func TestRepositoryIntegration(t *testing.T) {

     

       18
       18
       -
       	// Skip if not running integration tests

     

       19
       19
       -
       	if testing.Short() {

     

       20
       20
       -
       		t.Skip("Skipping integration test")

     

       21
       21
       -
       	}

     

       22
       22
       -
       

     

       23
       23
       -
       	// Use test database URL from environment or default

     

       24
       24
       -
       	dbURL := os.Getenv("TEST_DATABASE_URL")

     

       25
       25
       -
       	if dbURL == "" {

     

       26
       26
       -
       		dbURL = "postgres://test_user:test_password@localhost:5434/coves_test?sslmode=disable"

     

       27
       27
       -
       	}

     

       28
       28
       -
       

     

       29
       29
       -
       	// Connect to test database with sql.DB for migrations

     

       30
       30
       -
       	sqlDB, err := sql.Open("postgres", dbURL)

     

       31
       31
       -
       	if err != nil {

     

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

     

       33
       33
       -
       	}

     

       34
       34
       -
       	defer sqlDB.Close()

     

       35
       35
       -
       

     

       36
       36
       -
       	// Run migrations

     

       37
       37
       -
       	if err := goose.Up(sqlDB, "../../internal/db/migrations"); err != nil {

     

       38
       38
       -
       		t.Fatalf("Failed to run migrations: %v", err)

     

       39
       39
       -
       	}

     

       40
       40
       -
       

     

       41
       41
       -
       	// Connect with GORM for carstore

     

       42
       42
       -
       	gormDB, err := gorm.Open(postgresDriver.Open(dbURL), &gorm.Config{

     

       43
       43
       -
       		DisableForeignKeyConstraintWhenMigrating: true,

     

       44
       44
       -
       		PrepareStmt: false,

     

       45
       45
       -
       	})

     

       46
       46
       -
       	if err != nil {

     

       47
       47
       -
       		t.Fatalf("Failed to create GORM connection: %v", err)

     

       48
       48
       -
       	}

     

       49
       49
       -
       

     

       50
       50
       -
       	// Create temporary directory for carstore

     

       51
       51
       -
       	tempDir, err := os.MkdirTemp("", "carstore_integration_test")

     

       52
       52
       -
       	if err != nil {

     

       53
       53
       -
       		t.Fatalf("Failed to create temp dir: %v", err)

     

       54
       54
       -
       	}

     

       55
       55
       -
       	defer os.RemoveAll(tempDir)

     

       56
       56
       -
       

     

       57
       57
       -
       	// Initialize carstore

     

       58
       58
       -
       	carDirs := []string{tempDir}

     

       59
       59
       -
       	repoStore, err := carstore.NewRepoStore(gormDB, carDirs)

     

       60
       60
       -
       	if err != nil {

     

       61
       61
       -
       		t.Fatalf("Failed to create repo store: %v", err)

     

       62
       62
       -
       	}

     

       63
       63
       -
       

     

       64
       64
       -
       	// Create repository repo

     

       65
       65
       -
       	repoRepo := postgres.NewRepositoryRepo(sqlDB)

     

       66
       66
       -
       	

     

       67
       67
       -
       	// Create service with both repo and repoStore

     

       68
       68
       -
       	service := repository.NewService(repoRepo, repoStore)

     

       69
       69
       -
       	

     

       70
       70
       -
       	// Test creating a repository

     

       71
       71
       -
       	did := "did:plc:testuser123"

     

       72
       72
       -
       	service.SetSigningKey(did, "mock-signing-key")

     

       73
       73
       -
       	

     

       74
       74
       -
       	repo, err := service.CreateRepository(did)

     

       75
       75
       -
       	if err != nil {

     

       76
       76
       -
       		t.Fatalf("Failed to create repository: %v", err)

     

       77
       77
       -
       	}

     

       78
       78
       -
       	

     

       79
       79
       -
       	if repo.DID != did {

     

       80
       80
       -
       		t.Errorf("Expected DID %s, got %s", did, repo.DID)

     

       81
       81
       -
       	}

     

       82
       82
       -
       	

     

       83
       83
       -
       	// Test getting the repository

     

       84
       84
       -
       	fetchedRepo, err := service.GetRepository(did)

     

       85
       85
       -
       	if err != nil {

     

       86
       86
       -
       		t.Fatalf("Failed to get repository: %v", err)

     

       87
       87
       -
       	}

     

       88
       88
       -
       	

     

       89
       89
       -
       	if fetchedRepo.DID != did {

     

       90
       90
       -
       		t.Errorf("Expected DID %s, got %s", did, fetchedRepo.DID)

     

       91
       91
       -
       	}

     

       92
       92
       -
       	

     

       93
       93
       -
       	// Clean up

     

       94
       94
       -
       	err = service.DeleteRepository(did)

     

       95
       95
       -
       	if err != nil {

     

       96
       96
       -
       		t.Fatalf("Failed to delete repository: %v", err)

     

       97
       97
       -
       	}

     

       98
       98
       -
       

     

       99
       99
       -
       	// Clean up test data

     

       100
       100
       -
       	gormDB.Exec("DELETE FROM repositories")

     

       101
       101
       -
       	gormDB.Exec("DELETE FROM user_maps")

     

       102
       102
       -
       	gormDB.Exec("DELETE FROM car_shards")

     

       103
       103
       -
       }