Files
whatshooked/PHASE2_UPDATES.md
Hein f9773bd07f
Some checks failed
CI / Test (1.23) (push) Failing after -22m46s
CI / Test (1.22) (push) Failing after -22m32s
CI / Build (push) Failing after -23m30s
CI / Lint (push) Failing after -23m12s
refactor(API): Relspect integration
2026-02-05 13:39:43 +02:00

326 lines
7.9 KiB
Markdown

# Phase 2 Update - New Backend Tools Applied
## What Changed
Based on the updated PLAN.md, I've applied the following new tools and requirements:
### ✅ Completed Updates:
#### 1. **Makefile Enhancement**
Updated the existing Makefile with new Phase 2 commands:
**New Commands Added:**
- `make build-ui` - Build frontend
- `make dev-ui` - Run frontend in dev mode
- `make generate-models` - Generate BUN models from DBML
- `make migrate / migrate-up / migrate-down` - Database migrations
- `make migrate-create NAME=<name>` - Create new migration
- `make setup-migrations` - Setup migration infrastructure
- `make seed` - Seed database with initial data
- `make install-relspecgo` - Install relspecgo tool
- `make install-tools` - Install all development tools
**Usage:**
```bash
make help # See all available commands
```
#### 2. **DBML Schema Definition**
Created complete database schema in DBML format:
**File:** `sql/schema.dbml`
**Tables Defined:**
- users
- api_keys
- hooks
- whatsapp_accounts
- event_logs
- sessions
- message_cache
**Features:**
- All relationships defined
- Indexes specified
- Constraints (unique, not null, foreign keys)
- Cascade delete rules
- Soft delete support
- Timestamps with defaults
#### 3. **SQL Directory Structure**
Created organized SQL structure:
```
sql/
├── schema.dbml # Main schema definition (DBML)
├── postgres/ # PostgreSQL migrations
│ ├── [timestamp]_*.up.sql
│ └── [timestamp]_*.down.sql
└── sqlite/ # SQLite migrations
├── [timestamp]_*.up.sql
└── [timestamp]_*.down.sql
```
#### 4. **Tool Documentation**
Created comprehensive documentation:
**New Files:**
- `tooldoc/RELSPECGO.md` - Complete relspecgo guide
- Installation and usage
- DBML syntax reference
- Model generation workflow
- Integration with ResolveSpec
- Best practices
- `tooldoc/BUN_ORM.md` - Complete BUN ORM guide
- Database setup (PostgreSQL & SQLite)
- Model definition with tags
- CRUD operations
- Relationships (has-many, belongs-to, many-to-many)
- Queries and filtering
- Transactions
- ResolveSpec integration
- Performance tips
- Testing patterns
## Next Steps
### Remaining Tasks:
1. **Convert from GORM to BUN** (High Priority)
- Install BUN dependencies
- Generate models from DBML using relspecgo
- Update storage package to use BUN
- Update repository implementations
- Test all database operations
2. **Update WebServer** (High Priority)
- Use ResolveSpec's server package directly
- Leverage ResolveSpec's built-in security
- Use ResolveSpec authentication features
- Remove custom authentication (use ResolveSpec's)
3. **Create Migrations**
- Generate SQL migrations from DBML
- Create migration scripts
- Setup migrate.sh script
4. **Frontend** (Medium Priority)
- Initialize React + Mantine + TanStack Start project
- Integrate Oranguru
- Build UI components
## How to Use New Tools
### 1. Generate BUN Models
```bash
# Install relspecgo
make install-relspecgo
# Generate models from DBML
make generate-models
# This creates models in pkg/models/ from sql/schema.dbml
```
### 2. Create Migration
```bash
# Create new migration files
make migrate-create NAME=init_schema
# Edit the generated files in:
# - sql/postgres/[timestamp]_init_schema.up.sql
# - sql/postgres/[timestamp]_init_schema.down.sql
# - sql/sqlite/[timestamp]_init_schema.up.sql
# - sql/sqlite/[timestamp]_init_schema.down.sql
```
### 3. Run Migrations
```bash
# Setup migration infrastructure first
make setup-migrations
# Run migrations
make migrate-up
# Rollback
make migrate-down
```
### 4. Build Everything
```bash
# Build backend and frontend
make build
# Or separately
make build-backend # Server + CLI
make build-ui # Frontend only
```
## Updated Workflow
### Development Flow:
1. **Schema Changes:**
```bash
# Edit sql/schema.dbml
make generate-models
make migrate-create NAME=my_change
# Edit migration files
make migrate-up
```
2. **Backend Development:**
```bash
# Run tests
make test
# Lint code
make lint
# Run server
make run-server
```
3. **Frontend Development:**
```bash
# Run in dev mode
make dev-ui
# Build for production
make build-ui
```
## Benefits of New Approach
### relspecgo + BUN:
1. **Single Source of Truth**: DBML defines everything
2. **Type Safety**: Generated Go models are type-safe
3. **Consistency**: Same schema for PostgreSQL and SQLite
4. **Documentation**: DBML serves as schema documentation
5. **Fast Development**: Auto-generate models and migrations
6. **SQL-First**: BUN is SQL-first, giving you control
### Makefile:
1. **Standardized Commands**: Same commands work across team
2. **Easy Onboarding**: `make help` shows everything
3. **Automation**: Complex tasks simplified
4. **Cross-Platform**: Works on Linux, macOS, Windows (WSL)
### ResolveSpec Integration:
1. **Less Code**: Built-in server, security, auth
2. **Best Practices**: Professional-grade patterns
3. **Maintenance**: Less custom code to maintain
4. **Features**: REST + ResolveSpec + security out of the box
## File Structure
```
whatshooked/
├── Makefile # ✅ Updated with Phase 2 commands
├── sql/
│ ├── schema.dbml # ✅ Complete DBML schema
│ ├── postgres/ # ✅ PostgreSQL migrations
│ └── sqlite/ # ✅ SQLite migrations
├── pkg/
│ ├── models/ # 📋 To be generated from DBML
│ ├── storage/ # 🔄 To be updated for BUN
│ ├── auth/ # 🔄 To use ResolveSpec auth
│ └── webserver/ # 🔄 To use ResolveSpec server
├── tooldoc/
│ ├── CODE_GUIDELINES.md # ✅ Complete
│ ├── RELSPECGO.md # ✅ New - relspecgo guide
│ ├── BUN_ORM.md # ✅ New - BUN ORM guide
│ ├── RESOLVESPEC.md # ✅ Complete
│ ├── ORANGURU.md # ✅ Complete
│ └── REACT_MANTINE_TANSTACK.md # ✅ Complete
└── frontend/ # 📋 To be created
Legend:
✅ Complete
🔄 Needs updating
📋 To be done
```
## Commands Reference
```bash
# Build
make build # Build everything
make build-backend # Build server + CLI
make build-ui # Build frontend
# Development
make run-server # Run server
make dev-ui # Run frontend dev server
# Database
make generate-models # Generate BUN models from DBML
make migrate-up # Run migrations
make migrate-down # Rollback migrations
make migrate-create NAME=<name> # Create migration
make seed # Seed database
# Quality
make test # Run tests
make lint # Run linter
make lintfix # Run linter with auto-fix
# Dependencies
make deps # Install all dependencies
make install-relspecgo # Install relspecgo
make install-tools # Install dev tools
# Help
make help # Show all commands
```
## What's Different from Previous Implementation
### Before (GORM):
- Manual model definitions
- GORM tags
- Custom migrations
- More boilerplate
### After (BUN + DBML):
- DBML schema definition
- Auto-generated BUN models
- relspecgo for generation
- Standardized via Makefile
- Less boilerplate
### Before (Custom Server):
- Custom auth implementation
- Manual middleware
- Custom server setup
### After (ResolveSpec):
- Built-in authentication
- Built-in security
- Server package included
- Less custom code
## Next Implementation Steps
1. Run `make install-relspecgo`
2. Run `make generate-models`
3. Update pkg/storage to use BUN
4. Update pkg/webserver to use ResolveSpec server package
5. Create migration scripts
6. Test database operations
7. Initialize frontend project
The foundation is now properly set up following the updated PLAN.md requirements!