base/internal/repository/postgres/auth/mapper.go

package auth

import (
	"encoding/json"
	"time"

	"gorm.io/gorm"

	domainAuth "base/internal/domain/auth"
	"base/internal/pkg/oauth"
)

func toUserModel(user *domainAuth.User) *UserModel {
	// Note: DisplayName exists in schema but not in domain model
	// Compute it from FirstName + LastName
	displayName := user.FirstName + " " + user.LastName
	return &UserModel{
		ID:             user.ID,
		FirstName:      user.FirstName,
		LastName:       user.LastName,
		DisplayName:    displayName,
		PhoneNumber:    user.PhoneNumber,
		Email:          user.Email,
		EmailVerified:  user.EmailVerified,
		Status:         int(user.Status),
		InvitationCode: user.InvitationCode,
		CreatedAt:      user.CreatedAt,
		UpdatedAt:      user.UpdatedAt,
		DeletedAt:      gorm.DeletedAt{Time: user.DeletedAt, Valid: !user.DeletedAt.IsZero()},
	}
}

func toUserDomain(model *UserModel) *domainAuth.User {
	var deletedAt time.Time
	if model.DeletedAt.Valid {
		deletedAt = model.DeletedAt.Time
	}
	return &domainAuth.User{
		ID:             model.ID,
		FirstName:      model.FirstName,
		LastName:       model.LastName,
		PhoneNumber:    model.PhoneNumber,
		Email:          model.Email,
		EmailVerified:  model.EmailVerified,
		Status:         domainAuth.UserStatus(model.Status),
		InvitationCode: model.InvitationCode,
		CreatedAt:      model.CreatedAt,
		UpdatedAt:      model.UpdatedAt,
		DeletedAt:      deletedAt,
	}
}

func copyUserFromModel(user *domainAuth.User, model *UserModel) {
	user.ID = model.ID
	user.PhoneNumber = model.PhoneNumber
	user.EmailVerified = model.EmailVerified
	user.Status = domainAuth.UserStatus(model.Status)
	user.InvitationCode = model.InvitationCode
	user.CreatedAt = model.CreatedAt
	user.UpdatedAt = model.UpdatedAt
	if model.DeletedAt.Valid {
		user.DeletedAt = model.DeletedAt.Time
	}
}

func toRoleModel(role *domainAuth.Role) *RoleModel {
	desc := &role.Description
	if role.Description == "" {
		desc = nil
	}
	return &RoleModel{
		ID:          role.ID,
		Name:        role.Name,
		Description: desc,
		CreatedAt:   role.CreatedAt,
		UpdatedAt:   role.UpdatedAt,
	}
}

func toRoleDomain(model *RoleModel) *domainAuth.Role {
	desc := ""
	if model.Description != nil {
		desc = *model.Description
	}
	return &domainAuth.Role{
		ID:          model.ID,
		Name:        model.Name,
		Description: desc,
		CreatedAt:   model.CreatedAt,
		UpdatedAt:   model.UpdatedAt,
	}
}

func copyRoleFromModel(role *domainAuth.Role, model *RoleModel) error {
	role.ID = model.ID
	role.CreatedAt = model.CreatedAt
	role.UpdatedAt = model.UpdatedAt
	return nil
}

func toAccountModel(account *domainAuth.Account) *AccountModel {
	var scopeStr *string
	if len(account.Scope) > 0 {
		scopeBytes, _ := json.Marshal(account.Scope)
		s := string(scopeBytes)
		scopeStr = &s
	}

	// Store provider in Meta JSONB field
	metaMap := make(map[string]interface{})
	if len(account.Meta) > 0 {
		_ = json.Unmarshal(account.Meta, &metaMap)
	}
	metaMap["provider"] = int(account.Provider)
	metaBytes, _ := json.Marshal(metaMap)
	meta := json.RawMessage(metaBytes)

	return &AccountModel{
		ID:           account.ID,
		UserID:       account.UserID,
		Provider:     int(account.Provider), // Store provider as column for querying
		Password:     account.Password,
		AccessToken:  account.AccessToken,
		RefreshToken: account.RefreshToken,
		Scope:        scopeStr,
		Meta:         &meta,
		CreatedAt:    account.CreatedAt,
		UpdatedAt:    account.UpdatedAt,
	}
}

func toAccountDomain(model *AccountModel) *domainAuth.Account {
	var scope []string
	if model.Scope != nil {
		_ = json.Unmarshal([]byte(*model.Scope), &scope)
	}

	var meta json.RawMessage
	var provider int

	// Use Provider field if available (for querying), otherwise extract from Meta
	if model.Provider > 0 {
		provider = model.Provider
	}

	if model.Meta != nil {
		meta = *model.Meta
		// If provider not set from field, try to extract from Meta
		if provider == 0 {
			var metaMap map[string]interface{}
			if err := json.Unmarshal(meta, &metaMap); err == nil {
				if p, ok := metaMap["provider"].(float64); ok {
					provider = int(p)
				}
			}
		}
	}

	// Import oauth package for Provider type
	// Provider is stored as int, convert to oauth.Provider
	var accountProvider oauth.Provider
	if provider > 0 {
		accountProvider = oauth.Provider(provider)
	}

	return &domainAuth.Account{
		ID:           model.ID,
		UserID:       model.UserID,
		Provider:     accountProvider,
		Password:     model.Password,
		AccessToken:  model.AccessToken,
		RefreshToken: model.RefreshToken,
		Scope:        scope,
		Meta:         meta,
		CreatedAt:    model.CreatedAt,
		UpdatedAt:    model.UpdatedAt,
	}
}

func copyAccountFromModel(account *domainAuth.Account, model *AccountModel) {
	account.ID = model.ID
	account.CreatedAt = model.CreatedAt
	account.UpdatedAt = model.UpdatedAt
}