Deploy files from GitHub repository

config/supabase_config.go

@@ -1,9 +1,18 @@
 package config
 
+type SupabaseSMTPConfig struct {
+	Host     string
+	Port     string
+	Username string
+	Password string
+	Sender   string
+}
+
 type SupabaseConfig interface {
 	GetURL() string
 	GetServiceKey() string
 	GetBucketName() string
+	GetSMTP() SupabaseSMTPConfig
 	GetSMTPHost() string
 	GetSMTPPort() string
 	GetSMTPUsername() string
@@ -12,34 +21,33 @@ type SupabaseConfig interface {
 }
 
 type supabaseConfig struct {
-	url          string
-	serviceKey   string
-	bucketName   string
-	smtpHost     string
-	smtpPort     string
-	smtpUsername string
-	smtpPassword string
-	smtpSender   string
+	url        string
+	serviceKey string
+	bucketName string
+	smtp       SupabaseSMTPConfig
 }
 
 func NewSupabaseConfig(url string, key string, bucket string, smtpHost string, smtpPort string, smtpUsername string, smtpPassword string, smtpSender string) SupabaseConfig {
 	return &supabaseConfig{
-		url:          url,
-		serviceKey:   key,
-		bucketName:   bucket,
-		smtpHost:     smtpHost,
-		smtpPort:     smtpPort,
-		smtpUsername: smtpUsername,
-		smtpPassword: smtpPassword,
-		smtpSender:   smtpSender,
+		url:        url,
+		serviceKey: key,
+		bucketName: bucket,
+		smtp: SupabaseSMTPConfig{
+			Host:     smtpHost,
+			Port:     smtpPort,
+			Username: smtpUsername,
+			Password: smtpPassword,
+			Sender:   smtpSender,
+		},
 	}
 }
 
-func (c *supabaseConfig) GetURL() string          { return c.url }
-func (c *supabaseConfig) GetServiceKey() string   { return c.serviceKey }
-func (c *supabaseConfig) GetBucketName() string   { return c.bucketName }
-func (c *supabaseConfig) GetSMTPHost() string     { return c.smtpHost }
-func (c *supabaseConfig) GetSMTPPort() string     { return c.smtpPort }
-func (c *supabaseConfig) GetSMTPUsername() string { return c.smtpUsername }
-func (c *supabaseConfig) GetSMTPPassword() string { return c.smtpPassword }
-func (c *supabaseConfig) GetSMTPSender() string   { return c.smtpSender }
+func (c *supabaseConfig) GetURL() string              { return c.url }
+func (c *supabaseConfig) GetServiceKey() string       { return c.serviceKey }
+func (c *supabaseConfig) GetBucketName() string       { return c.bucketName }
+func (c *supabaseConfig) GetSMTP() SupabaseSMTPConfig { return c.smtp }
+func (c *supabaseConfig) GetSMTPHost() string         { return c.smtp.Host }
+func (c *supabaseConfig) GetSMTPPort() string         { return c.smtp.Port }
+func (c *supabaseConfig) GetSMTPUsername() string     { return c.smtp.Username }
+func (c *supabaseConfig) GetSMTPPassword() string     { return c.smtp.Password }
+func (c *supabaseConfig) GetSMTPSender() string       { return c.smtp.Sender }

services/supabase_email_verification_service.go

@@ -1,18 +1,17 @@
 package services
 
 import (
+	"bytes"
 	"context"
-	"crypto/tls"
+	"encoding/json"
 	"fmt"
-	"net"
-	"net/mail"
-	"net/smtp"
+	"io"
+	"net/http"
 	"strings"
 	"time"
 
 	"abdanhafidz.com/go-boilerplate/config"
 	http_error "abdanhafidz.com/go-boilerplate/models/error"
-	storage_go "github.com/supabase-community/storage-go"
 )
 
 type SupabaseEmailVerificationService interface {
@@ -20,40 +19,33 @@ type SupabaseEmailVerificationService interface {
 }
 
 type supabaseEmailVerificationService struct {
-	smtpHost   string
-	smtpPort   string
-	smtpUser   string
-	smtpPass   string
-	smtpSender string
-	client     *storage_go.Client
+	supabaseURL string
+	serviceKey  string
+	smtp        config.SupabaseSMTPConfig
+	httpClient  *http.Client
 }
 
 const (
 	verificationEmailSubject = "Kode OTP Verifikasi Email Quzuu"
 	verificationEmailBodyFmt = "Kode OTP kamu adalah %s. Kode ini berlaku selama 15 menit."
+	supabaseEmailOTPPath     = "/auth/v1/otp"
 )
 
 func NewSupabaseEmailVerificationService(supabaseConfig config.SupabaseConfig) SupabaseEmailVerificationService {
 	baseURL := strings.TrimRight(strings.TrimSpace(supabaseConfig.GetURL()), "/")
 	serviceKey := strings.TrimSpace(supabaseConfig.GetServiceKey())
-
-	var client *storage_go.Client
-	if baseURL != "" && serviceKey != "" {
-		client = storage_go.NewClient(baseURL+"/storage/v1", serviceKey, nil)
-	}
-
-	port := strings.TrimSpace(supabaseConfig.GetSMTPPort())
-	if port == "" {
-		port = "587"
-	}
+	smtp := supabaseConfig.GetSMTP()
+	smtp.Host = strings.TrimSpace(smtp.Host)
+	smtp.Port = strings.TrimSpace(smtp.Port)
+	smtp.Username = strings.TrimSpace(smtp.Username)
+	smtp.Password = strings.TrimSpace(smtp.Password)
+	smtp.Sender = strings.TrimSpace(smtp.Sender)
 
 	return &supabaseEmailVerificationService{
-		smtpHost:   strings.TrimSpace(supabaseConfig.GetSMTPHost()),
-		smtpPort:   port,
-		smtpUser:   strings.TrimSpace(supabaseConfig.GetSMTPUsername()),
-		smtpPass:   strings.TrimSpace(supabaseConfig.GetSMTPPassword()),
-		smtpSender: strings.TrimSpace(supabaseConfig.GetSMTPSender()),
-		client:     client,
+		supabaseURL: baseURL,
+		serviceKey:  serviceKey,
+		smtp:        smtp,
+		httpClient:  &http.Client{Timeout: 15 * time.Second},
 	}
 }
 
@@ -62,128 +54,86 @@ func (s *supabaseEmailVerificationService) SendEmailVerification(ctx context.Con
 	if trimmedEmail == "" {
 		return http_error.BAD_REQUEST_ERROR
 	}
-	if !s.isSMTPConfigured() {
-		return fmt.Errorf("%w: SMTP config is incomplete", http_error.SEND_EMAIL_FAILED)
+	if !s.isSupabaseConfigured() {
+		return fmt.Errorf("%w: Supabase email configuration is incomplete", http_error.SEND_EMAIL_FAILED)
+	}
+	if s.hasAnySMTPConfig() && !s.isSMTPConfigured() {
+		return fmt.Errorf("%w: Supabase SMTP configuration is incomplete", http_error.SEND_EMAIL_FAILED)
 	}
 
 	tokenCode := fmt.Sprintf("%06d", token)
-	return s.sendViaSMTP(ctx, trimmedEmail, tokenCode)
+	return s.sendViaSupabase(ctx, trimmedEmail, tokenCode)
+}
+
+func (s *supabaseEmailVerificationService) isSupabaseConfigured() bool {
+	return strings.TrimSpace(s.supabaseURL) != "" && strings.TrimSpace(s.serviceKey) != ""
+}
+
+func (s *supabaseEmailVerificationService) hasAnySMTPConfig() bool {
+	return strings.TrimSpace(s.smtp.Host) != "" ||
+		strings.TrimSpace(s.smtp.Port) != "" ||
+		strings.TrimSpace(s.smtp.Username) != "" ||
+		strings.TrimSpace(s.smtp.Password) != "" ||
+		strings.TrimSpace(s.smtp.Sender) != ""
 }
 
 func (s *supabaseEmailVerificationService) isSMTPConfigured() bool {
-	return strings.TrimSpace(s.smtpHost) != "" &&
-		strings.TrimSpace(s.smtpUser) != "" &&
-		strings.TrimSpace(s.smtpPass) != "" &&
-		strings.TrimSpace(s.smtpSender) != ""
+	return strings.TrimSpace(s.smtp.Host) != "" &&
+		strings.TrimSpace(s.smtp.Port) != "" &&
+		strings.TrimSpace(s.smtp.Username) != "" &&
+		strings.TrimSpace(s.smtp.Password) != "" &&
+		strings.TrimSpace(s.smtp.Sender) != ""
 }
 
-func (s *supabaseEmailVerificationService) sendViaSMTP(ctx context.Context, email string, tokenCode string) error {
+func (s *supabaseEmailVerificationService) sendViaSupabase(ctx context.Context, email string, tokenCode string) error {
 	select {
 	case <-ctx.Done():
 		return http_error.TIMEOUT
 	default:
 	}
 
-	host := strings.TrimSpace(s.smtpHost)
-	port := strings.TrimSpace(s.smtpPort)
-
-	subject := verificationEmailSubject
-	body := fmt.Sprintf(verificationEmailBodyFmt, tokenCode)
-	fromHeader := strings.TrimSpace(s.smtpSender)
-	fromEnvelope := fromHeader
-
-	if parsedFrom, err := mail.ParseAddress(fromHeader); err == nil {
-		fromEnvelope = parsedFrom.Address
+	payload := map[string]any{
+		"email":       email,
+		"create_user": true,
+		"data": map[string]string{
+			"verification_subject": verificationEmailSubject,
+			"verification_message": fmt.Sprintf(verificationEmailBodyFmt, tokenCode),
+			"verification_code":    tokenCode,
+		},
 	}
 
-	message := strings.Join([]string{
-		fmt.Sprintf("From: %s", fromHeader),
-		fmt.Sprintf("To: %s", email),
-		fmt.Sprintf("Subject: %s", subject),
-		"MIME-Version: 1.0",
-		`Content-Type: text/plain; charset="UTF-8"`,
-		"",
-		body,
-	}, "\r\n")
-
-	client, err := s.newSMTPClient(ctx, host, port)
+	body, err := json.Marshal(payload)
 	if err != nil {
-		if ctx.Err() != nil {
-			return http_error.TIMEOUT
-		}
-		return fmt.Errorf("%w: SMTP dial failed (%s:%s): %v", http_error.SEND_EMAIL_FAILED, host, port, err)
-	}
-	defer client.Close()
-
-	auth := smtp.PlainAuth("", s.smtpUser, s.smtpPass, host)
-	if err := client.Auth(auth); err != nil {
-		return fmt.Errorf("%w: SMTP auth failed: %v", http_error.SEND_EMAIL_FAILED, err)
-	}
-	if err := client.Mail(fromEnvelope); err != nil {
-		return fmt.Errorf("%w: SMTP MAIL FROM failed (%s): %v", http_error.SEND_EMAIL_FAILED, fromEnvelope, err)
-	}
-	if err := client.Rcpt(email); err != nil {
-		return fmt.Errorf("%w: SMTP RCPT TO failed (%s): %v", http_error.SEND_EMAIL_FAILED, email, err)
+		return http_error.INTERNAL_SERVER_ERROR
 	}
 
-	dataWriter, err := client.Data()
+	requestURL := s.supabaseURL + supabaseEmailOTPPath
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, requestURL, bytes.NewReader(body))
 	if err != nil {
-		return fmt.Errorf("%w: SMTP DATA open failed: %v", http_error.SEND_EMAIL_FAILED, err)
-	}
-	if _, err := dataWriter.Write([]byte(message)); err != nil {
-		_ = dataWriter.Close()
-		return fmt.Errorf("%w: SMTP DATA write failed: %v", http_error.SEND_EMAIL_FAILED, err)
-	}
-	if err := dataWriter.Close(); err != nil {
-		return fmt.Errorf("%w: SMTP DATA close failed: %v", http_error.SEND_EMAIL_FAILED, err)
-	}
-
-	if err := client.Quit(); err != nil {
-		return fmt.Errorf("%w: SMTP QUIT failed: %v", http_error.SEND_EMAIL_FAILED, err)
-	}
-	return nil
-}
-
-func (s *supabaseEmailVerificationService) newSMTPClient(ctx context.Context, host string, port string) (*smtp.Client, error) {
-	addr := net.JoinHostPort(host, port)
-	dialer := &net.Dialer{Timeout: 5 * time.Minute}
-
-	if port == "465" {
-		conn, err := tls.DialWithDialer(dialer, "tcp", addr, &tls.Config{
-			ServerName: host,
-			MinVersion: tls.VersionTLS12,
-		})
-		if err != nil {
-			return nil, err
-		}
-		client, err := smtp.NewClient(conn, host)
-		if err != nil {
-			_ = conn.Close()
-			return nil, err
-		}
-		return client, nil
+		return http_error.INTERNAL_SERVER_ERROR
 	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("apikey", s.serviceKey)
+	req.Header.Set("Authorization", "Bearer "+s.serviceKey)
 
-	conn, err := dialer.DialContext(ctx, "tcp", addr)
+	res, err := s.httpClient.Do(req)
 	if err != nil {
-		return nil, err
+		if ctx.Err() != nil {
+			return http_error.TIMEOUT
+		}
+		return fmt.Errorf("%w: Supabase email request failed: %v", http_error.SEND_EMAIL_FAILED, err)
 	}
+	defer res.Body.Close()
 
-	client, err := smtp.NewClient(conn, host)
-	if err != nil {
-		_ = conn.Close()
-		return nil, err
+	if res.StatusCode >= http.StatusOK && res.StatusCode < http.StatusMultipleChoices {
+		return nil
 	}
 
-	if ok, _ := client.Extension("STARTTLS"); ok {
-		if err := client.StartTLS(&tls.Config{
-			ServerName: host,
-			MinVersion: tls.VersionTLS12,
-		}); err != nil {
-			_ = client.Close()
-			return nil, err
-		}
+	errBody, _ := io.ReadAll(io.LimitReader(res.Body, 8*1024))
+	detail := strings.TrimSpace(string(errBody))
+	if detail == "" {
+		detail = res.Status
 	}
 
-	return client, nil
+	return fmt.Errorf("%w: Supabase email request rejected (%d): %s", http_error.SEND_EMAIL_FAILED, res.StatusCode, detail)
 }