feat(notification): implement CreateNotification API (#2708)

Part of #2215 (RFC: #2680)

- Proto: CreateNotificationRequest carries repeated localizations
  (language, tags, title, Markdown content); response returns the
  created Notification.
- Domain: NewNotification creates a DRAFT with UUID, editor email as
  created_by/last_edited_by, and timestamps.
- Storage: NotificationStorage interface with MySQL and PostgreSQL
  implementations inserting the notification row and one localization
  row per language (tags as JSON).
- API: system-admin-only handler with request validation, running the
  inserts in a transaction; wired with storage in the web server for
  both database backends.
- Unit tests for domain, both storage implementations, and the API
  handler.

Author: hvn2k1

api-description/web-api.swagger.yaml

@@ -14182,8 +14182,18 @@ definitions:
         title: Sorted by yearmonth ascending
   notificationCreateNotificationRequest:
     type: object
+    properties:
+      localizations:
+        type: array
+        items:
+          type: object
+          $ref: '#/definitions/notificationNotificationLocalization'
+        description: At least one localization is required; languages must be unique.
   notificationCreateNotificationResponse:
     type: object
+    properties:
+      notification:
+        $ref: '#/definitions/notificationNotification'
   notificationDeleteNotificationResponse:
     type: object
   notificationGetNotificationResponse:
@@ -14202,6 +14212,72 @@ definitions:
     type: object
   notificationMarkNotificationsAsReadResponse:
     type: object
+  notificationNotification:
+    type: object
+    properties:
+      id:
+        type: string
+      status:
+        $ref: '#/definitions/notificationNotificationStatus'
+      createdBy:
+        type: string
+      lastEditedBy:
+        type: string
+      publishedBy:
+        type: string
+      publishedAt:
+        type: string
+        format: int64
+        description: Epoch seconds; 0 while draft.
+      createdAt:
+        type: string
+        format: int64
+      updatedAt:
+        type: string
+        format: int64
+      localization:
+        $ref: '#/definitions/notificationNotificationLocalization'
+        description: |-
+          Localization resolved to the requested language, falling back to
+          English, then to whichever localization exists.
+      localizations:
+        type: array
+        items:
+          type: object
+          $ref: '#/definitions/notificationNotificationLocalization'
+        description: All localizations; populated only for system admins (editor).
+      read:
+        type: boolean
+        description: Whether the requesting user has read this notification.
+  notificationNotificationLocalization:
+    type: object
+    properties:
+      language:
+        type: string
+        description: BCP 47 language code, e.g. "en", "ja".
+      tags:
+        type: array
+        items:
+          type: object
+          $ref: '#/definitions/notificationNotificationTag'
+      title:
+        type: string
+      content:
+        type: string
+        description: Markdown source.
+  notificationNotificationStatus:
+    type: string
+    enum:
+      - DRAFT
+      - PUBLISHED
+    default: DRAFT
+  notificationNotificationTag:
+    type: object
+    properties:
+      name:
+        type: string
+      color:
+        type: string
   notificationPublishNotificationRequest:
     type: object
   notificationPublishNotificationResponse:

pkg/error/error.go

@@ -25,6 +25,7 @@ const (
 	AccountPackageName      = "account"
 	FeaturePackageName      = "feature"
 	SubscriptionPackageName = "subscription"
+	NotificationPackageName = "notification"
 	PushPackageName         = "push"
 	TagPackageName          = "tag"
 	EventCounterPackageName = "eventcounter"

pkg/notification/api/api.go

@@ -16,17 +16,24 @@ package api
 
 import (
 	"context"
+	"errors"
+	"strings"
 
 	"go.uber.org/zap"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	gstatus "google.golang.org/grpc/status"
 
+	"github.com/bucketeer-io/bucketeer/v2/pkg/api/api"
+	"github.com/bucketeer-io/bucketeer/v2/pkg/log"
+	"github.com/bucketeer-io/bucketeer/v2/pkg/notification/domain"
+	"github.com/bucketeer-io/bucketeer/v2/pkg/notification/storage"
+	"github.com/bucketeer-io/bucketeer/v2/pkg/role"
+	"github.com/bucketeer-io/bucketeer/v2/pkg/storage/v2/database"
+	eventproto "github.com/bucketeer-io/bucketeer/v2/proto/event/domain"
 	proto "github.com/bucketeer-io/bucketeer/v2/proto/notification"
 )
 
-var statusNotImplemented = gstatus.Error(codes.Unimplemented, "notification: not implemented")
-
 type options struct {
 	logger *zap.Logger
 }
@@ -40,27 +47,64 @@ func WithLogger(l *zap.Logger) Option {
 }
 
 type NotificationService struct {
-	opts   *options
-	logger *zap.Logger
+	dbClient            database.Client
+	notificationStorage storage.NotificationStorage
+	opts                *options
+	logger              *zap.Logger
 }
 
-func NewNotificationService(opts ...Option) *NotificationService {
+func NewNotificationService(
+	dbClient database.Client,
+	notificationStorage storage.NotificationStorage,
+	opts ...Option,
+) *NotificationService {
 	dopts := &options{
 		logger: zap.NewNop(),
 	}
 	for _, opt := range opts {
 		opt(dopts)
 	}
 	return &NotificationService{
-		opts:   dopts,
-		logger: dopts.logger.Named("api"),
+		dbClient:            dbClient,
+		notificationStorage: notificationStorage,
+		opts:                dopts,
+		logger:              dopts.logger.Named("api"),
 	}
 }
 
 func (s *NotificationService) Register(server *grpc.Server) {
 	proto.RegisterNotificationServiceServer(server, s)
 }
 
+func (s *NotificationService) checkSystemAdminRole(
+	ctx context.Context,
+) (*eventproto.Editor, error) {
+	editor, err := role.CheckSystemAdminRole(ctx)
+	if err != nil {
+		switch gstatus.Code(err) {
+		case codes.Unauthenticated:
+			s.logger.Error(
+				"Unauthenticated",
+				log.FieldsFromIncomingContext(ctx).AddFields(zap.Error(err))...,
+			)
+			return nil, statusUnauthenticated.Err()
+		case codes.PermissionDenied:
+			s.logger.Error(
+				"Permission denied",
+				log.FieldsFromIncomingContext(ctx).AddFields(zap.Error(err))...,
+			)
+			return nil, statusPermissionDenied.Err()
+		default:
+			s.logger.Error(
+				"Failed to check role",
+				log.FieldsFromIncomingContext(ctx).AddFields(zap.Error(err))...,
+			)
+			return nil, api.NewGRPCStatus(err).Err()
+		}
+	}
+	return editor, nil
+}
+
 func (s *NotificationService) ListNotifications(
 	ctx context.Context,
 	req *proto.ListNotificationsRequest,
@@ -107,7 +151,69 @@ func (s *NotificationService) CreateNotification(
 	ctx context.Context,
 	req *proto.CreateNotificationRequest,
 ) (*proto.CreateNotificationResponse, error) {
-	return nil, statusNotImplemented
+	editor, err := s.checkSystemAdminRole(ctx)
+	if err != nil {
+		return nil, err
+	}
+	if err := validateCreateNotificationRequest(req); err != nil {
+		s.logger.Error(
+			"Failed to validate create notification request",
+			log.FieldsFromIncomingContext(ctx).AddFields(zap.Error(err))...,
+		)
+		return nil, err
+	}
+	notification, err := domain.NewNotification(editor.Email, req.Localizations)
+	if err != nil {
+		s.logger.Error(
+			"Failed to create new notification",
+			log.FieldsFromIncomingContext(ctx).AddFields(zap.Error(err))...,
+		)
+		return nil, api.NewGRPCStatus(err).Err()
+	}
+	err = s.dbClient.RunInTransactionV2(ctx, func(ctxWithTx context.Context) error {
+		return s.notificationStorage.CreateNotification(ctxWithTx, notification)
+	})
+	if err != nil {
+		if errors.Is(err, storage.ErrNotificationAlreadyExists) {
+			return nil, statusNotificationAlreadyExists.Err()
+		}
+		s.logger.Error(
+			"Failed to create notification",
+			log.FieldsFromIncomingContext(ctx).AddFields(
+				zap.Error(err),
+				zap.String("notificationId", notification.Id),
+			)...,
+		)
+		return nil, api.NewGRPCStatus(err).Err()
+	}
+	return &proto.CreateNotificationResponse{
+		Notification: notification.Notification,
+	}, nil
+}
+
+func validateCreateNotificationRequest(req *proto.CreateNotificationRequest) error {
+	if len(req.Localizations) == 0 {
+		return statusLocalizationRequired.Err()
+	}
+	languages := make(map[string]struct{}, len(req.Localizations))
+	for _, l := range req.Localizations {
+		l.Language = strings.TrimSpace(l.Language)
+		l.Title = strings.TrimSpace(l.Title)
+		if l.Language == "" {
+			return statusLanguageRequired.Err()
+		}
+		if _, ok := languages[l.Language]; ok {
+			return statusDuplicatedLanguage.Err()
+		}
+		languages[l.Language] = struct{}{}
+		if l.Title == "" {
+			return statusTitleRequired.Err()
+		}
+		if strings.TrimSpace(l.Content) == "" {
+			return statusContentRequired.Err()
+		}
+	}
+	return nil
 }
 
 func (s *NotificationService) UpdateNotification(