initial commit

internal/repository/postgres/auth/mapper.go

@@ -0,0 +1,184 @@
+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
+}