Commit Graph

7 Commits

Author SHA1 Message Date
juanatsap 219b83bfc0 docs: Complete _go-learning documentation with diagrams, patterns, and best practices
Added comprehensive educational documentation to fill empty folders:

## Architecture Diagrams (8 files)
- System architecture with layered design
- Complete request/response flow diagrams
- Middleware chain execution details
- Handler organization structure
- Data model relationships
- Error handling flows
- Template rendering pipeline
- PDF generation process with Chromedp

## Go Patterns (9 files)
- Pattern catalog and usage guide
- Middleware pattern (HTTP chain composition)
- Handler pattern (method-based organization)
- Context pattern (request-scoped values)
- Error wrapping (typed errors, chains)
- Dependency injection (constructor-based)
- Template pattern (rendering pipeline)
- Singleton pattern (thread-safe instances)
- Factory pattern (error/response constructors)

## Best Practices (2 files)
- Best practices catalog and quick reference
- Code organization (project structure, naming)

All documentation includes:
- Real examples from this project
- ASCII diagrams for visualization
- Best practices and anti-patterns
- Testing examples
- Performance considerations

Documentation structure:
- 20 markdown files
- ~6,000+ lines of educational content
- Cross-referenced between topics
- Practical, project-based examples
2025-11-20 20:27:38 +00:00
juanatsap faf3a2ca45 docs: Add comprehensive system architecture diagrams
Created detailed ASCII diagrams documenting the entire system architecture:

1. System Architecture (_go-learning/diagrams/01-system-architecture.md)
   - Overall system architecture with client/server/storage layers
   - Layered architecture (Presentation → Application → Business → Data)
   - Component interaction and HTTP request flow
   - Data flow from app start through per-request lifecycle
   - Package dependencies and file organization
2025-11-20 20:17:29 +00:00
juanatsap c23068508f docs: Add comprehensive documentation for architectural enhancements
Created detailed documentation for all 5 architectural improvements:

Educational Documentation (_go-learning/):
- Created 005-architectural-enhancements.md (900+ lines)
- Detailed explanation of each enhancement
- Code examples and usage patterns
- Before/after comparisons
- Benefits and interview talking points
- Future considerations

Public Documentation (doc/):
- Updated 14-BACKEND-HANDLERS.md
- Added "Architectural Enhancements" section
- Response Types with examples
- Validation Tags guide
- Context Helpers usage
- Typed Errors documentation
- Performance Benchmarks guide
- Updated table of contents
- Updated changelog

Documentation Coverage:
- Response Types: Structure, helpers, usage examples
- Validation Tags: Declarative rules, self-documenting
- Context Helpers: 13 functions documented
- Typed Errors: 13 error codes, constructors, usage
- Benchmarks: 23 benchmarks, running instructions

All improvements now fully documented for:
- Internal learning and interviews
- Public consumption and contribution
- Developer onboarding
- Architecture understanding
2025-11-20 18:24:41 +00:00
juanatsap 8a709c6863 improve: Add type safety, middleware, and comprehensive handler tests
Five complementary improvements to handler layer:

1. Fix Pre-Commit Hook
   - Remove broken Perl-style regex (unsupported by Go)
   - Use -short flag to exclude integration tests
   - Tests now run successfully in pre-commit

2. Extract Duplicate Logic
   - Remove 100+ lines of duplicate data preparation
   - Both Home() and CVContent() now use prepareTemplateData()
   - Reduce cv_pages.go from 290 to 120 lines (58% reduction)

3. Request/Response Types
   - Create internal/handlers/types.go with structured types
   - PDFExportRequest, LanguageRequest, PreferenceToggleRequest
   - Type-safe parameter parsing with centralized validation
   - Refactor ExportPDF to use typed requests

4. Middleware Extraction
   - Create internal/middleware/preferences.go
   - PreferencesMiddleware reads cookies once, stores in context
   - Automatic migration of old preference values
   - Ready for integration in routes

5. Handler Tests
   - Add internal/handlers/cv_pages_test.go (190 lines, 15+ cases)
   - Add internal/handlers/cv_htmx_test.go (325 lines, 20+ cases)
   - Test language validation, toggles, cookies, methods
   - Increase handler test coverage significantly

Testing:
- All unit tests pass (35+ new test cases)
- Pre-commit hook working
- Build succeeds
- No breaking changes

Benefits:
- Type safety: Compile-time parameter validation
- Code quality: 170 lines of duplication eliminated
- Testing: 100% increase in test files
- Architecture: Clean middleware pattern
- Developer experience: Self-documenting request types

Documentation:
- Create _go-learning/refactorings/004-handler-improvements.md
- Document all five improvements with examples
- Include metrics, testing strategy, and future improvements
2025-11-20 17:28:23 +00:00
juanatsap 4acde64c01 refactor: Split monolithic handler into focused files
Split internal/handlers/cv.go (1,001 lines) into 5 focused files:

Structure:
- cv.go (29 lines) - CVHandler struct + constructor
- cv_pages.go (290 lines) - Page handlers (Home, CVContent, DefaultCVShortcut)
- cv_pdf.go (153 lines) - PDF export handler (ExportPDF)
- cv_htmx.go (218 lines) - HTMX toggle handlers (Length, Icons, Language, Theme)
- cv_helpers.go (385 lines) - Helper functions (skills, dates, git, templates, cookies)

Benefits:
- Single Responsibility: Each file has one clear purpose
- Improved Discoverability: Easy to find specific functionality
- Reduced Cognitive Load: 200-400 lines per file vs 1,001
- Parallel Development: No conflicts when editing different concerns
- Better Organization: Clear section markers and grouping
- Maintainability: Trade +74 lines (+7.4%) for better organization

Testing:
- All Go tests pass (fileutil, handlers, lang, cv, ui)
- Server builds and runs correctly
- All HTTP endpoints functional
- No breaking changes

Documentation:
- Create _go-learning/refactorings/003-handler-split.md
- Document architecture, benefits, and trade-offs
- Explain WHY single package vs separate packages
2025-11-20 17:01:50 +00:00
juanatsap 9240a863d1 refactor: Extract shared utilities and add validation layer
Part 1: Shared Utilities
- Create internal/fileutil package with FindDataFile() and LoadJSON()
- Create internal/lang package with language constants and validation
- Eliminate 46 lines of code duplication between cv/loader.go and ui/loader.go
- Simplify cv/loader.go from 69 to 36 lines (-48%)
- Simplify ui/loader.go from 56 to 24 lines (-57%)

Part 2: Validation Layer
- Add comprehensive validation in internal/models/cv/validation.go
- Validate Personal (name, email format, URLs)
- Validate Experience (required fields, dates)
- Validate Education (required fields)
- Validate Skills (proficiency ranges 1-5, categories)
- Validate Languages (proficiency levels 1-5)
- Validate Projects (title, URLs)
- Validate Meta (version, language)
- Integrate validation into LoadCV() - automatic on load
- Create ValidationError and ValidationErrors types for clear error reporting
- Report all validation errors at once (better UX)

Testing:
- Add comprehensive tests for fileutil package (FindDataFile, LoadJSON)
- Add tests for lang package (IsValid, Validate, All)
- Add 280+ validation test cases covering edge cases
- All tests pass with real CV data (cv-en.json, cv-es.json)
- Fixed validation to allow both URLs and local paths for gitRepoUrl

Documentation:
- Create _go-learning/refactorings/002-shared-utilities-validation.md
- Document architecture, benefits, testing, and interview talking points
- Explain WHY decisions were made (DRY, type safety, data integrity)

Benefits:
- DRY: Single source of truth for utilities
- Type safety: Language constants instead of magic strings
- Data integrity: Validation catches errors at load time
- Better errors: Clear messages showing all issues at once
- Maintainability: Centralized utilities easier to update
2025-11-20 16:41:13 +00:00
juanatsap 7b60fdcf9c refactor: Separate CV domain and UI presentation models into distinct packages
**Main Changes:**

1. **Package Restructuring** - Separated mixed concerns into focused packages:
   - Created `internal/models/cv/` for CV domain logic (CV, Personal, Experience, etc.)
   - Created `internal/models/ui/` for UI presentation logic (InfoModal, ShortcutsModal, etc.)
   - Removed monolithic `internal/models/cv.go` (300+ lines → organized packages)

2. **Testing** - Added comprehensive unit tests:
   - `internal/models/cv/loader_test.go` - CV data loading and validation
   - `internal/models/ui/loader_test.go` - UI translations loading
   - All tests passing 

3. **Documentation** - Added Go learning knowledge base:
   - `_go-learning/architecture/server-design.md` - Goroutines, graceful shutdown explained
   - `_go-learning/refactorings/001-cv-model-separation.md` - This refactoring documented
   - Public documentation showcasing Go expertise (README.md kept private)

4. **Handler Updates** - Updated imports to use new package structure:
   - `internal/handlers/cv.go` - Uses `cvmodel` and `uimodel` aliases

**Benefits:**
-  Clear separation of concerns (domain vs presentation)
-  Better testability (isolated package testing)
-  Improved maintainability (smaller, focused files)
-  Scalability (each domain can evolve independently)
-  Follows Go best practices (small, cohesive packages)

**Other Updates:**
- Updated middleware security checks
- Template improvements
- Organized completed prompts

**Testing:**
- All Go unit tests pass (cv, ui, handlers)
- Server verified with curl tests (English, Spanish, Health endpoints)
- Frontend functionality unchanged (refactoring is transparent to UI)
2025-11-20 16:17:56 +00:00