feat(refactor): Implement 1A.1 Package Structure Refactoring

This commit implements the package structure refactoring as outlined in phase1.md (Task 1A.1).

Key changes include:
- Reorganized packages into `pkg/garmin` for public API and `internal/` for internal implementations.
- Updated all import paths to reflect the new structure.
- Consolidated types and client logic into their respective new packages.
- Updated `cmd/garth/main.go` to use the new public API.
- Fixed various compilation and test issues encountered during the refactoring process.
- Converted `internal/api/client/auth_test.go` to a functional test.

This establishes a solid foundation for future enhancements and improves maintainability.

internal/data/base.go

@@ -0,0 +1,130 @@
+package data
+
+import (
+	"errors"
+	"sync"
+	"time"
+
+	"garmin-connect/internal/api/client"
+	"garmin-connect/internal/utils"
+)
+
+// Data defines the interface for Garmin Connect data types.
+// Concrete data types (BodyBattery, HRV, Sleep, etc.) must implement this interface.
+//
+// The Get method retrieves data for a single day.
+// The List method concurrently retrieves data for a range of days.
+type Data interface {
+	Get(day time.Time, c *client.Client) (interface{}, error)
+	List(end time.Time, days int, c *client.Client, maxWorkers int) ([]interface{}, error)
+}
+
+// BaseData provides a reusable implementation for data types to embed.
+// It handles the concurrent List() implementation while allowing concrete types
+// to focus on implementing the Get() method for their specific data structure.
+//
+// Usage:
+//
+//	type BodyBatteryData struct {
+//	    data.BaseData
+//	    // ... additional fields
+//	}
+//
+//	func NewBodyBatteryData() *BodyBatteryData {
+//	    bb := &BodyBatteryData{}
+//	    bb.GetFunc = bb.get // Assign the concrete Get implementation
+//	    return bb
+//	}
+//
+//	func (bb *BodyBatteryData) get(day time.Time, c *client.Client) (interface{}, error) {
+//	    // Implementation specific to body battery data
+//	}
+type BaseData struct {
+	// GetFunc must be set by concrete types to implement the Get method.
+	// This function pointer allows BaseData to call the concrete implementation.
+	GetFunc func(day time.Time, c *client.Client) (interface{}, error)
+}
+
+// Get implements the Data interface by calling the configured GetFunc.
+// Returns an error if GetFunc is not set.
+func (b *BaseData) Get(day time.Time, c *client.Client) (interface{}, error) {
+	if b.GetFunc == nil {
+		return nil, errors.New("GetFunc not implemented for this data type")
+	}
+	return b.GetFunc(day, c)
+}
+
+// List implements concurrent data fetching using a worker pool pattern.
+// This method efficiently retrieves data for multiple days by distributing
+// work across a configurable number of workers (goroutines).
+//
+// Parameters:
+//
+//	end: The end date of the range (inclusive)
+//	days: Number of days to fetch (going backwards from end date)
+//	c: Client instance for API access
+//	maxWorkers: Maximum concurrent workers (minimum 1)
+//
+// Returns:
+//
+//	[]interface{}: Slice of results (order matches date range)
+//	[]error: Slice of errors encountered during processing
+func (b *BaseData) List(end time.Time, days int, c *client.Client, maxWorkers int) ([]interface{}, []error) {
+	if maxWorkers < 1 {
+		maxWorkers = 10 // Match Python's MAX_WORKERS
+	}
+
+	dates := utils.DateRange(end, days)
+
+	// Define result type for channel
+	type result struct {
+		data interface{}
+		err  error
+	}
+
+	var wg sync.WaitGroup
+	workCh := make(chan time.Time, days)
+	resultsCh := make(chan result, days)
+
+	// Worker function
+	worker := func() {
+		defer wg.Done()
+		for date := range workCh {
+			data, err := b.Get(date, c)
+			resultsCh <- result{data: data, err: err}
+		}
+	}
+
+	// Start workers
+	wg.Add(maxWorkers)
+	for i := 0; i < maxWorkers; i++ {
+		go worker()
+	}
+
+	// Send work
+	go func() {
+		for _, date := range dates {
+			workCh <- date
+		}
+		close(workCh)
+	}()
+
+	// Close results channel when workers are done
+	go func() {
+		wg.Wait()
+		close(resultsCh)
+	}()
+
+	var results []interface{}
+	var errs []error
+
+	for r := range resultsCh {
+		if r.err != nil {
+			errs = append(errs, r.err)
+		} else if r.data != nil {
+			results = append(results, r.data)
+		}
+	}
+
+	return results, errs
+}

internal/data/base_test.go

@@ -0,0 +1,74 @@
+package data
+
+import (
+	"errors"
+	"testing"
+	"time"
+
+	"garmin-connect/internal/api/client"
+
+	"github.com/stretchr/testify/assert"
+)
+
+// MockData implements Data interface for testing
+type MockData struct {
+	BaseData
+}
+
+// MockClient simulates API client for tests
+type MockClient struct{}
+
+func (mc *MockClient) Get(endpoint string) (interface{}, error) {
+	if endpoint == "error" {
+		return nil, errors.New("mock API error")
+	}
+	return "data for " + endpoint, nil
+}
+
+func TestBaseData_List(t *testing.T) {
+	// Setup mock data type
+	mockData := &MockData{}
+	mockData.GetFunc = func(day time.Time, c *client.Client) (interface{}, error) {
+		return "data for " + day.Format("2006-01-02"), nil
+	}
+
+	// Test parameters
+	end := time.Date(2023, 6, 15, 0, 0, 0, 0, time.UTC)
+	days := 5
+	c := &client.Client{}
+	maxWorkers := 3
+
+	// Execute
+	results, errs := mockData.List(end, days, c, maxWorkers)
+
+	// Verify
+	assert.Empty(t, errs)
+	assert.Len(t, results, days)
+	assert.Contains(t, results, "data for 2023-06-15")
+	assert.Contains(t, results, "data for 2023-06-11")
+}
+
+func TestBaseData_List_ErrorHandling(t *testing.T) {
+	// Setup mock data type that returns error on specific date
+	mockData := &MockData{}
+	mockData.GetFunc = func(day time.Time, c *client.Client) (interface{}, error) {
+		if day.Day() == 13 {
+			return nil, errors.New("bad luck day")
+		}
+		return "data for " + day.Format("2006-01-02"), nil
+	}
+
+	// Test parameters
+	end := time.Date(2023, 6, 15, 0, 0, 0, 0, time.UTC)
+	days := 5
+	c := &client.Client{}
+	maxWorkers := 2
+
+	// Execute
+	results, errs := mockData.List(end, days, c, maxWorkers)
+
+	// Verify
+	assert.Len(t, errs, 1)
+	assert.Equal(t, "bad luck day", errs[0].Error())
+	assert.Len(t, results, 4) // Should have results for non-error days
+}

internal/data/body_battery.go

@@ -0,0 +1,138 @@
+package data
+
+import (
+	"encoding/json"
+	"fmt"
+	"sort"
+	"time"
+
+	"garmin-connect/internal/api/client"
+)
+
+// DailyBodyBatteryStress represents complete daily Body Battery and stress data
+type DailyBodyBatteryStress struct {
+	UserProfilePK          int       `json:"userProfilePk"`
+	CalendarDate           time.Time `json:"calendarDate"`
+	StartTimestampGMT      time.Time `json:"startTimestampGmt"`
+	EndTimestampGMT        time.Time `json:"endTimestampGmt"`
+	StartTimestampLocal    time.Time `json:"startTimestampLocal"`
+	EndTimestampLocal      time.Time `json:"endTimestampLocal"`
+	MaxStressLevel         int       `json:"maxStressLevel"`
+	AvgStressLevel         int       `json:"avgStressLevel"`
+	StressChartValueOffset int       `json:"stressChartValueOffset"`
+	StressChartYAxisOrigin int       `json:"stressChartYAxisOrigin"`
+	StressValuesArray      [][]int   `json:"stressValuesArray"`
+	BodyBatteryValuesArray [][]any   `json:"bodyBatteryValuesArray"`
+}
+
+// BodyBatteryEvent represents a Body Battery impact event
+type BodyBatteryEvent struct {
+	EventType              string    `json:"eventType"`
+	EventStartTimeGMT      time.Time `json:"eventStartTimeGmt"`
+	TimezoneOffset         int       `json:"timezoneOffset"`
+	DurationInMilliseconds int       `json:"durationInMilliseconds"`
+	BodyBatteryImpact      int       `json:"bodyBatteryImpact"`
+	FeedbackType           string    `json:"feedbackType"`
+	ShortFeedback          string    `json:"shortFeedback"`
+}
+
+// BodyBatteryData represents legacy Body Battery events data
+type BodyBatteryData struct {
+	Event                  *BodyBatteryEvent `json:"event"`
+	ActivityName           string            `json:"activityName"`
+	ActivityType           string            `json:"activityType"`
+	ActivityID             string            `json:"activityId"`
+	AverageStress          float64           `json:"averageStress"`
+	StressValuesArray      [][]int           `json:"stressValuesArray"`
+	BodyBatteryValuesArray [][]any           `json:"bodyBatteryValuesArray"`
+}
+
+// BodyBatteryReading represents an individual Body Battery reading
+type BodyBatteryReading struct {
+	Timestamp int     `json:"timestamp"`
+	Status    string  `json:"status"`
+	Level     int     `json:"level"`
+	Version   float64 `json:"version"`
+}
+
+// StressReading represents an individual stress reading
+type StressReading struct {
+	Timestamp   int `json:"timestamp"`
+	StressLevel int `json:"stressLevel"`
+}
+
+// ParseBodyBatteryReadings converts body battery values array to structured readings
+func ParseBodyBatteryReadings(valuesArray [][]any) []BodyBatteryReading {
+	readings := make([]BodyBatteryReading, 0)
+	for _, values := range valuesArray {
+		if len(values) < 4 {
+			continue
+		}
+
+		timestamp, ok1 := values[0].(int)
+		status, ok2 := values[1].(string)
+		level, ok3 := values[2].(int)
+		version, ok4 := values[3].(float64)
+
+		if !ok1 || !ok2 || !ok3 || !ok4 {
+			continue
+		}
+
+		readings = append(readings, BodyBatteryReading{
+			Timestamp: timestamp,
+			Status:    status,
+			Level:     level,
+			Version:   version,
+		})
+	}
+	sort.Slice(readings, func(i, j int) bool {
+		return readings[i].Timestamp < readings[j].Timestamp
+	})
+	return readings
+}
+
+// ParseStressReadings converts stress values array to structured readings
+func ParseStressReadings(valuesArray [][]int) []StressReading {
+	readings := make([]StressReading, 0)
+	for _, values := range valuesArray {
+		if len(values) != 2 {
+			continue
+		}
+		readings = append(readings, StressReading{
+			Timestamp:   values[0],
+			StressLevel: values[1],
+		})
+	}
+	sort.Slice(readings, func(i, j int) bool {
+		return readings[i].Timestamp < readings[j].Timestamp
+	})
+	return readings
+}
+
+// Get implements the Data interface for DailyBodyBatteryStress
+func (d *DailyBodyBatteryStress) Get(day time.Time, client *client.Client) (any, error) {
+	dateStr := day.Format("2006-01-02")
+	path := fmt.Sprintf("/wellness-service/wellness/dailyStress/%s", dateStr)
+
+	data, err := client.ConnectAPI(path, "GET", nil, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(data) == 0 {
+		return nil, nil
+	}
+
+	var result DailyBodyBatteryStress
+	if err := json.Unmarshal(data, &result); err != nil {
+		return nil, err
+	}
+
+	return &result, nil
+}
+
+// List implements the Data interface for concurrent fetching
+func (d *DailyBodyBatteryStress) List(end time.Time, days int, client *client.Client, maxWorkers int) ([]any, error) {
+	// Implementation to be added
+	return []any{}, nil
+}

internal/data/body_battery_test.go

@@ -0,0 +1,122 @@
+package data
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestParseBodyBatteryReadings(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    [][]any
+		expected []BodyBatteryReading
+	}{
+		{
+			name: "valid readings",
+			input: [][]any{
+				{1000, "ACTIVE", 75, 1.0},
+				{2000, "ACTIVE", 70, 1.0},
+				{3000, "REST", 65, 1.0},
+			},
+			expected: []BodyBatteryReading{
+				{1000, "ACTIVE", 75, 1.0},
+				{2000, "ACTIVE", 70, 1.0},
+				{3000, "REST", 65, 1.0},
+			},
+		},
+		{
+			name: "invalid readings",
+			input: [][]any{
+				{1000, "ACTIVE", 75},           // missing version
+				{2000, "ACTIVE"},               // missing level and version
+				{3000},                         // only timestamp
+				{"invalid", "ACTIVE", 75, 1.0}, // wrong timestamp type
+			},
+			expected: []BodyBatteryReading{},
+		},
+		{
+			name:     "empty input",
+			input:    [][]any{},
+			expected: []BodyBatteryReading{},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := ParseBodyBatteryReadings(tt.input)
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func TestParseStressReadings(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    [][]int
+		expected []StressReading
+	}{
+		{
+			name: "valid readings",
+			input: [][]int{
+				{1000, 25},
+				{2000, 30},
+				{3000, 20},
+			},
+			expected: []StressReading{
+				{1000, 25},
+				{2000, 30},
+				{3000, 20},
+			},
+		},
+		{
+			name: "invalid readings",
+			input: [][]int{
+				{1000},        // missing stress level
+				{2000, 30, 1}, // extra value
+				{},            // empty
+			},
+			expected: []StressReading{},
+		},
+		{
+			name:     "empty input",
+			input:    [][]int{},
+			expected: []StressReading{},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := ParseStressReadings(tt.input)
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func TestDailyBodyBatteryStress(t *testing.T) {
+	now := time.Now()
+	d := DailyBodyBatteryStress{
+		CalendarDate: now,
+		BodyBatteryValuesArray: [][]any{
+			{1000, "ACTIVE", 75, 1.0},
+			{2000, "ACTIVE", 70, 1.0},
+		},
+		StressValuesArray: [][]int{
+			{1000, 25},
+			{2000, 30},
+		},
+	}
+
+	t.Run("body battery readings", func(t *testing.T) {
+		readings := ParseBodyBatteryReadings(d.BodyBatteryValuesArray)
+		assert.Len(t, readings, 2)
+		assert.Equal(t, 75, readings[0].Level)
+	})
+
+	t.Run("stress readings", func(t *testing.T) {
+		readings := ParseStressReadings(d.StressValuesArray)
+		assert.Len(t, readings, 2)
+		assert.Equal(t, 25, readings[0].StressLevel)
+	})
+}

internal/data/hrv.go

@@ -0,0 +1,211 @@
+package data
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"sort"
+	"time"
+
+	"garmin-connect/internal/api/client"
+	"garmin-connect/internal/utils"
+)
+
+// HRVSummary represents Heart Rate Variability summary data
+type HRVSummary struct {
+	UserProfilePK     int       `json:"userProfilePk"`
+	CalendarDate      time.Time `json:"calendarDate"`
+	StartTimestampGMT time.Time `json:"startTimestampGmt"`
+	EndTimestampGMT   time.Time `json:"endTimestampGmt"`
+	WeeklyAvg         float64   `json:"weeklyAvg"`
+	LastNightAvg      float64   `json:"lastNightAvg"`
+	Baseline          float64   `json:"baseline"`
+}
+
+// HRVReading represents an individual HRV reading
+type HRVReading struct {
+	Timestamp     int     `json:"timestamp"`
+	StressLevel   int     `json:"stressLevel"`
+	HeartRate     int     `json:"heartRate"`
+	RRInterval    int     `json:"rrInterval"`
+	Status        string  `json:"status"`
+	SignalQuality float64 `json:"signalQuality"`
+}
+
+// TimestampAsTime converts the reading timestamp to time.Time using timeutils
+func (r *HRVReading) TimestampAsTime() time.Time {
+	return utils.ParseTimestamp(r.Timestamp)
+}
+
+// RRSeconds converts the RR interval to seconds
+func (r *HRVReading) RRSeconds() float64 {
+	return float64(r.RRInterval) / 1000.0
+}
+
+// HRVData represents complete HRV data
+type HRVData struct {
+	UserProfilePK int          `json:"userProfilePk"`
+	HRVSummary    HRVSummary   `json:"hrvSummary"`
+	HRVReadings   []HRVReading `json:"hrvReadings"`
+	BaseData
+}
+
+// Validate ensures HRVSummary fields meet requirements
+func (h *HRVSummary) Validate() error {
+	if h.WeeklyAvg < 0 {
+		return errors.New("WeeklyAvg must be non-negative")
+	}
+	if h.LastNightAvg < 0 {
+		return errors.New("LastNightAvg must be non-negative")
+	}
+	if h.Baseline < 0 {
+		return errors.New("Baseline must be non-negative")
+	}
+	if h.CalendarDate.IsZero() {
+		return errors.New("CalendarDate must be set")
+	}
+	if h.StartTimestampGMT.IsZero() || h.EndTimestampGMT.IsZero() {
+		return errors.New("Timestamps must be set")
+	}
+	if h.EndTimestampGMT.Before(h.StartTimestampGMT) {
+		return errors.New("EndTimestampGMT must be after StartTimestampGMT")
+	}
+	return nil
+}
+
+// Validate ensures HRVReading fields meet requirements
+func (r *HRVReading) Validate() error {
+	if r.StressLevel < 0 || r.StressLevel > 100 {
+		return fmt.Errorf("StressLevel must be between 0-100, got %d", r.StressLevel)
+	}
+	if r.HeartRate <= 0 {
+		return fmt.Errorf("HeartRate must be positive, got %d", r.HeartRate)
+	}
+	if r.RRInterval <= 0 {
+		return fmt.Errorf("RRInterval must be positive, got %d", r.RRInterval)
+	}
+	if r.SignalQuality < 0 || r.SignalQuality > 1 {
+		return fmt.Errorf("SignalQuality must be between 0-1, got %f", r.SignalQuality)
+	}
+	return nil
+}
+
+// Validate ensures HRVData meets all requirements
+func (h *HRVData) Validate() error {
+	if h.UserProfilePK <= 0 {
+		return errors.New("UserProfilePK must be positive")
+	}
+	if err := h.HRVSummary.Validate(); err != nil {
+		return fmt.Errorf("HRVSummary validation failed: %w", err)
+	}
+	for i, reading := range h.HRVReadings {
+		if err := reading.Validate(); err != nil {
+			return fmt.Errorf("HRVReading[%d] validation failed: %w", i, err)
+		}
+	}
+	return nil
+}
+
+// DailyVariability calculates the average RR interval for the day
+func (h *HRVData) DailyVariability() float64 {
+	if len(h.HRVReadings) == 0 {
+		return 0
+	}
+	var total float64
+	for _, r := range h.HRVReadings {
+		total += r.RRSeconds()
+	}
+	return total / float64(len(h.HRVReadings))
+}
+
+// MinHRVReading returns the reading with the lowest RR interval
+func (h *HRVData) MinHRVReading() HRVReading {
+	if len(h.HRVReadings) == 0 {
+		return HRVReading{}
+	}
+	min := h.HRVReadings[0]
+	for _, r := range h.HRVReadings {
+		if r.RRInterval < min.RRInterval {
+			min = r
+		}
+	}
+	return min
+}
+
+// MaxHRVReading returns the reading with the highest RR interval
+func (h *HRVData) MaxHRVReading() HRVReading {
+	if len(h.HRVReadings) == 0 {
+		return HRVReading{}
+	}
+	max := h.HRVReadings[0]
+	for _, r := range h.HRVReadings {
+		if r.RRInterval > max.RRInterval {
+			max = r
+		}
+	}
+	return max
+}
+
+// ParseHRVReadings converts values array to structured readings
+func ParseHRVReadings(valuesArray [][]any) []HRVReading {
+	readings := make([]HRVReading, 0, len(valuesArray))
+	for _, values := range valuesArray {
+		if len(values) < 6 {
+			continue
+		}
+
+		// Extract values with type assertions
+		timestamp, _ := values[0].(int)
+		stressLevel, _ := values[1].(int)
+		heartRate, _ := values[2].(int)
+		rrInterval, _ := values[3].(int)
+		status, _ := values[4].(string)
+		signalQuality, _ := values[5].(float64)
+
+		readings = append(readings, HRVReading{
+			Timestamp:     timestamp,
+			StressLevel:   stressLevel,
+			HeartRate:     heartRate,
+			RRInterval:    rrInterval,
+			Status:        status,
+			SignalQuality: signalQuality,
+		})
+	}
+	sort.Slice(readings, func(i, j int) bool {
+		return readings[i].Timestamp < readings[j].Timestamp
+	})
+	return readings
+}
+
+// Get implements the Data interface for HRVData
+func (h *HRVData) Get(day time.Time, client *client.Client) (any, error) {
+	dateStr := day.Format("2006-01-02")
+	path := fmt.Sprintf("/wellness-service/wellness/dailyHrvData/%s?date=%s",
+		client.Username, dateStr)
+
+	data, err := client.ConnectAPI(path, "GET", nil, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(data) == 0 {
+		return nil, nil
+	}
+
+	var hrvData HRVData
+	if err := json.Unmarshal(data, &hrvData); err != nil {
+		return nil, err
+	}
+
+	if err := hrvData.Validate(); err != nil {
+		return nil, fmt.Errorf("HRV data validation failed: %w", err)
+	}
+
+	return hrvData, nil
+}
+
+// List implements the Data interface for concurrent fetching
+func (h *HRVData) List(end time.Time, days int, client *client.Client, maxWorkers int) ([]any, error) {
+	// Implementation to be added
+	return []any{}, nil
+}

internal/data/sleep.go

@@ -0,0 +1,74 @@
+package data
+
+import (
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"garmin-connect/internal/api/client"
+)
+
+// SleepScores represents sleep scoring data
+type SleepScores struct {
+	TotalSleepSeconds int `json:"totalSleepSeconds"`
+	SleepScores       []struct {
+		StartTimeGMT time.Time `json:"startTimeGmt"`
+		EndTimeGMT   time.Time `json:"endTimeGmt"`
+		SleepScore   int       `json:"sleepScore"`
+	} `json:"sleepScores"`
+	SleepMovement []SleepMovement `json:"sleepMovement"`
+	// Add other fields from Python implementation
+}
+
+// SleepMovement represents movement during sleep
+type SleepMovement struct {
+	StartGMT      time.Time `json:"startGmt"`
+	EndGMT        time.Time `json:"endGmt"`
+	ActivityLevel int       `json:"activityLevel"`
+}
+
+// DailySleepDTO represents daily sleep data
+type DailySleepDTO struct {
+	UserProfilePK          int         `json:"userProfilePk"`
+	CalendarDate           time.Time   `json:"calendarDate"`
+	SleepStartTimestampGMT time.Time   `json:"sleepStartTimestampGmt"`
+	SleepEndTimestampGMT   time.Time   `json:"sleepEndTimestampGmt"`
+	SleepScores            SleepScores `json:"sleepScores"`
+	BaseData
+}
+
+// Get implements the Data interface for DailySleepDTO
+func (d *DailySleepDTO) Get(day time.Time, client *client.Client) (any, error) {
+	dateStr := day.Format("2006-01-02")
+	path := fmt.Sprintf("/wellness-service/wellness/dailySleepData/%s?nonSleepBufferMinutes=60&date=%s",
+		client.Username, dateStr)
+
+	data, err := client.ConnectAPI(path, "GET", nil, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(data) == 0 {
+		return nil, nil
+	}
+
+	var response struct {
+		DailySleepDTO *DailySleepDTO  `json:"dailySleepDto"`
+		SleepMovement []SleepMovement `json:"sleepMovement"`
+	}
+	if err := json.Unmarshal(data, &response); err != nil {
+		return nil, err
+	}
+
+	if response.DailySleepDTO == nil {
+		return nil, nil
+	}
+
+	return response, nil
+}
+
+// List implements the Data interface for concurrent fetching
+func (d *DailySleepDTO) List(end time.Time, days int, client *client.Client, maxWorkers int) ([]any, error) {
+	// Implementation to be added
+	return []any{}, nil
+}

internal/data/weight.go

@@ -0,0 +1,81 @@
+package data
+
+import (
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"garmin-connect/internal/api/client"
+)
+
+// WeightData represents weight measurement data
+type WeightData struct {
+	UserProfilePK     int       `json:"userProfilePk"`
+	CalendarDate      time.Time `json:"calendarDate"`
+	Timestamp         time.Time `json:"timestamp"`
+	Weight            float64   `json:"weight"` // in kilograms
+	BMI               float64   `json:"bmi"`
+	BodyFatPercentage float64   `json:"bodyFatPercentage"`
+	BoneMass          float64   `json:"boneMass"`   // in kg
+	MuscleMass        float64   `json:"muscleMass"` // in kg
+	Hydration         float64   `json:"hydration"`  // in kg
+	BaseData
+}
+
+// Validate checks if weight data contains valid values
+func (w *WeightData) Validate() error {
+	if w.Weight <= 0 {
+		return fmt.Errorf("invalid weight value")
+	}
+	if w.BMI < 10 || w.BMI > 50 {
+		return fmt.Errorf("BMI out of valid range")
+	}
+	return nil
+}
+
+// Get implements the Data interface for WeightData
+func (w *WeightData) Get(day time.Time, client *client.Client) (any, error) {
+	startDate := day.Format("2006-01-02")
+	endDate := day.Format("2006-01-02")
+	path := fmt.Sprintf("/weight-service/weight/dateRange?startDate=%s&endDate=%s",
+		startDate, endDate)
+
+	data, err := client.ConnectAPI(path, "GET", nil, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(data) == 0 {
+		return nil, nil
+	}
+
+	var response struct {
+		WeightList []WeightData `json:"weightList"`
+	}
+	if err := json.Unmarshal(data, &response); err != nil {
+		return nil, err
+	}
+
+	if len(response.WeightList) == 0 {
+		return nil, nil
+	}
+
+	weightData := response.WeightList[0]
+	// Convert grams to kilograms
+	weightData.Weight = weightData.Weight / 1000
+	weightData.BoneMass = weightData.BoneMass / 1000
+	weightData.MuscleMass = weightData.MuscleMass / 1000
+	weightData.Hydration = weightData.Hydration / 1000
+
+	return weightData, nil
+}
+
+// List implements the Data interface for concurrent fetching
+func (w *WeightData) List(end time.Time, days int, client *client.Client, maxWorkers int) ([]any, error) {
+	results, errs := w.BaseData.List(end, days, client, maxWorkers)
+	if len(errs) > 0 {
+		// Return first error for now
+		return results, errs[0]
+	}
+	return results, nil
+}