feat(subscription): add skill subscription notification feature

server/skillhub-app/src/main/java/com/iflytek/skillhub/controller/portal/MeController.java

@@ -56,4 +56,16 @@ public ApiResponse<PageResponse<SkillSummaryResponse>> listMyStars(
 
         return ok("response.success.read", mySkillAppService.listMyStars(principal.userId(), page, size));
     }
+
+    @GetMapping("/subscriptions")
+    public ApiResponse<PageResponse<SkillSummaryResponse>> listMySubscriptions(
+            @RequestParam(defaultValue = "0") int page,
+            @RequestParam(defaultValue = "12") int size,
+            @AuthenticationPrincipal PlatformPrincipal principal) {
+        if (principal == null) {
+            throw new UnauthorizedException("error.auth.required");
+        }
+
+        return ok("response.success.read", mySkillAppService.listMySubscriptions(principal.userId(), page, size));
+    }
 }

server/skillhub-app/src/main/java/com/iflytek/skillhub/controller/portal/SkillController.java

@@ -86,6 +86,7 @@ public ApiResponse<SkillDetailResponse> getSkillDetail(
                 detail.status(),
                 detail.downloadCount(),
                 detail.starCount(),
+                detail.subscriptionCount(),
                 detail.ratingAvg(),
                 detail.ratingCount(),
                 detail.hidden(),

server/skillhub-app/src/main/java/com/iflytek/skillhub/controller/portal/SkillSubscriptionController.java

@@ -0,0 +1,49 @@
+package com.iflytek.skillhub.controller.portal;
+
+import com.iflytek.skillhub.auth.rbac.PlatformPrincipal;
+import com.iflytek.skillhub.controller.BaseApiController;
+import com.iflytek.skillhub.dto.ApiResponse;
+import com.iflytek.skillhub.dto.ApiResponseFactory;
+import com.iflytek.skillhub.domain.social.SkillSubscriptionService;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+import org.springframework.web.bind.annotation.*;
+
+@RestController
+@RequestMapping({"/api/v1/skills", "/api/web/skills"})
+public class SkillSubscriptionController extends BaseApiController {
+
+    private final SkillSubscriptionService skillSubscriptionService;
+
+    public SkillSubscriptionController(ApiResponseFactory responseFactory,
+                                       SkillSubscriptionService skillSubscriptionService) {
+        super(responseFactory);
+        this.skillSubscriptionService = skillSubscriptionService;
+    }
+
+    @PutMapping("/{skillId}/subscription")
+    public ApiResponse<Void> subscribeSkill(
+            @PathVariable Long skillId,
+            @AuthenticationPrincipal PlatformPrincipal principal) {
+        skillSubscriptionService.subscribe(skillId, principal.userId());
+        return ok("response.success.updated", null);
+    }
+
+    @DeleteMapping("/{skillId}/subscription")
+    public ApiResponse<Void> unsubscribeSkill(
+            @PathVariable Long skillId,
+            @AuthenticationPrincipal PlatformPrincipal principal) {
+        skillSubscriptionService.unsubscribe(skillId, principal.userId());
+        return ok("response.success.updated", null);
+    }
+
+    @GetMapping("/{skillId}/subscription")
+    public ApiResponse<Boolean> checkSubscribed(
+            @PathVariable Long skillId,
+            @AuthenticationPrincipal PlatformPrincipal principal) {
+        if (principal == null) {
+            return ok("response.success.read", false);
+        }
+        boolean subscribed = skillSubscriptionService.isSubscribed(skillId, principal.userId());
+        return ok("response.success.read", subscribed);
+    }
+}

server/skillhub-app/src/main/java/com/iflytek/skillhub/dto/SkillDetailResponse.java

@@ -14,6 +14,7 @@ public record SkillDetailResponse(
         String status,
         Long downloadCount,
         Integer starCount,
+        Integer subscriptionCount,
         BigDecimal ratingAvg,
         Integer ratingCount,
         boolean hidden,

server/skillhub-app/src/main/java/com/iflytek/skillhub/listener/NotificationEventListener.java

@@ -7,6 +7,7 @@
 import com.iflytek.skillhub.domain.skill.Skill;
 import com.iflytek.skillhub.domain.skill.SkillRepository;
 import com.iflytek.skillhub.domain.skill.SkillVersionRepository;
+import com.iflytek.skillhub.domain.social.SkillSubscriptionService;
 import com.iflytek.skillhub.notification.domain.NotificationCategory;
 import com.iflytek.skillhub.notification.service.NotificationDispatcher;
 import org.slf4j.Logger;
@@ -29,19 +30,22 @@ public class NotificationEventListener {
     private final NamespaceRepository namespaceRepository;
     private final RecipientResolver recipientResolver;
     private final NotificationDispatcher dispatcher;
+    private final SkillSubscriptionService skillSubscriptionService;
     private final ObjectMapper objectMapper;
 
     public NotificationEventListener(SkillRepository skillRepository,
                                       SkillVersionRepository skillVersionRepository,
                                       NamespaceRepository namespaceRepository,
                                       RecipientResolver recipientResolver,
                                       NotificationDispatcher dispatcher,
+                                      SkillSubscriptionService skillSubscriptionService,
                                       ObjectMapper objectMapper) {
         this.skillRepository = skillRepository;
         this.skillVersionRepository = skillVersionRepository;
         this.namespaceRepository = namespaceRepository;
         this.recipientResolver = recipientResolver;
         this.dispatcher = dispatcher;
+        this.skillSubscriptionService = skillSubscriptionService;
         this.objectMapper = objectMapper;
     }
 
@@ -61,6 +65,50 @@ public void onSkillPublished(SkillPublishedEvent event) {
         });
     }
 
+    @Async("skillhubEventExecutor")
+    @TransactionalEventListener
+    public void onSkillPublishedForSubscribers(SkillPublishedEvent event) {
+        skillRepository.findById(event.skillId()).ifPresent(skill -> {
+            List<String> subscribers = skillSubscriptionService.findSubscribersBySkillId(event.skillId());
+            if (subscribers.isEmpty()) {
+                return;
+            }
+            String title = "Skill updated: " + skillDisplayName(skill);
+            Map<String, Object> body = bodyWithSkill(skill);
+            versionLabel(event.versionId(), body);
+            String json = toJson(body);
+            for (String subscriberId : subscribers) {
+                if (subscriberId.equals(event.publisherId())) {
+                    continue; // skip the publisher
+                }
+                dispatcher.dispatch(subscriberId, NotificationCategory.PUBLISH,
+                        "SUBSCRIPTION_NEW_VERSION", title, json, "SKILL", event.skillId());
+            }
+        });
+    }
+
+    @Async("skillhubEventExecutor")
+    @TransactionalEventListener
+    public void onSkillVersionYankedForSubscribers(SkillVersionYankedEvent event) {
+        skillRepository.findById(event.skillId()).ifPresent(skill -> {
+            List<String> subscribers = skillSubscriptionService.findSubscribersBySkillId(event.skillId());
+            if (subscribers.isEmpty()) {
+                return;
+            }
+            String title = "Skill version yanked: " + skillDisplayName(skill);
+            Map<String, Object> body = bodyWithSkill(skill);
+            versionLabel(event.versionId(), body);
+            String json = toJson(body);
+            for (String subscriberId : subscribers) {
+                if (subscriberId.equals(event.actorUserId())) {
+                    continue; // skip the actor
+                }
+                dispatcher.dispatch(subscriberId, NotificationCategory.PUBLISH,
+                        "SUBSCRIPTION_VERSION_YANKED", title, json, "SKILL", event.skillId());
+            }
+        });
+    }
+
     @Async("skillhubEventExecutor")
     @TransactionalEventListener
     public void onReviewSubmitted(ReviewSubmittedEvent event) {

server/skillhub-app/src/main/java/com/iflytek/skillhub/service/MySkillAppService.java

@@ -5,6 +5,7 @@
 import com.iflytek.skillhub.domain.skill.SkillVersionRepository;
 import com.iflytek.skillhub.domain.skill.service.SkillLifecycleProjectionService;
 import com.iflytek.skillhub.domain.social.SkillStarRepository;
+import com.iflytek.skillhub.domain.social.SkillSubscriptionRepository;
 import com.iflytek.skillhub.dto.PageResponse;
 import com.iflytek.skillhub.dto.SkillSummaryResponse;
 import com.iflytek.skillhub.repository.MySkillQueryRepository;
@@ -32,18 +33,21 @@ public enum MySkillFilter {
     private final SkillRepository skillRepository;
     private final SkillVersionRepository skillVersionRepository;
     private final SkillStarRepository skillStarRepository;
+    private final SkillSubscriptionRepository skillSubscriptionRepository;
     private final MySkillQueryRepository mySkillQueryRepository;
     private final SkillLifecycleProjectionService skillLifecycleProjectionService;
 
     public MySkillAppService(
             SkillRepository skillRepository,
             SkillVersionRepository skillVersionRepository,
             SkillStarRepository skillStarRepository,
+            SkillSubscriptionRepository skillSubscriptionRepository,
             MySkillQueryRepository mySkillQueryRepository,
             SkillLifecycleProjectionService skillLifecycleProjectionService) {
         this.skillRepository = skillRepository;
         this.skillVersionRepository = skillVersionRepository;
         this.skillStarRepository = skillStarRepository;
+        this.skillSubscriptionRepository = skillSubscriptionRepository;
         this.mySkillQueryRepository = mySkillQueryRepository;
         this.skillLifecycleProjectionService = skillLifecycleProjectionService;
     }
@@ -90,6 +94,30 @@ public PageResponse<SkillSummaryResponse> listMyStars(String userId, int page, i
         return new PageResponse<>(items, starPage.getTotalElements(), starPage.getNumber(), starPage.getSize());
     }
 
+    public PageResponse<SkillSummaryResponse> listMySubscriptions(String userId, int page, int size) {
+        Page<com.iflytek.skillhub.domain.social.SkillSubscription> subPage = skillSubscriptionRepository.findByUserId(
+                userId,
+                PageRequest.of(page, size)
+        );
+        List<com.iflytek.skillhub.domain.social.SkillSubscription> subs = subPage.getContent();
+
+        List<Long> skillIds = subs.stream()
+                .map(com.iflytek.skillhub.domain.social.SkillSubscription::getSkillId)
+                .distinct()
+                .toList();
+        java.util.Map<Long, Skill> skillsById = skillIds.isEmpty()
+                ? java.util.Map.of()
+                : skillRepository.findByIdIn(skillIds).stream()
+                        .collect(java.util.stream.Collectors.toMap(Skill::getId, java.util.function.Function.identity()));
+        List<Skill> orderedSkills = subs.stream()
+                .map(sub -> skillsById.get(sub.getSkillId()))
+                .filter(java.util.Objects::nonNull)
+                .toList();
+        List<SkillSummaryResponse> items = mySkillQueryRepository.getSkillSummaries(orderedSkills, userId);
+
+        return new PageResponse<>(items, subPage.getTotalElements(), subPage.getNumber(), subPage.getSize());
+    }
+
     private Page<Skill> filterSkillsByLifecycle(String userId,
                                                 int page,
                                                 int size,

server/skillhub-app/src/main/java/com/iflytek/skillhub/service/ReviewSkillDetailAppService.java

@@ -67,6 +67,7 @@ public ReviewSkillDetailResponse getReviewSkillDetail(Long reviewId,
                 snapshot.skill().getStatus().name(),
                 snapshot.skill().getDownloadCount(),
                 snapshot.skill().getStarCount(),
+                snapshot.skill().getSubscriptionCount(),
                 snapshot.skill().getRatingAvg(),
                 snapshot.skill().getRatingCount(),
                 snapshot.skill().isHidden(),

server/skillhub-app/src/main/resources/db/migration/V40__skill_subscription.sql

@@ -0,0 +1,14 @@
+-- Skill subscription: users subscribe to skills for update notifications
+CREATE TABLE skill_subscription (
+    id          BIGSERIAL    PRIMARY KEY,
+    skill_id    BIGINT       NOT NULL REFERENCES skill(id) ON DELETE CASCADE,
+    user_id     VARCHAR(128) NOT NULL,
+    created_at  TIMESTAMPTZ  NOT NULL DEFAULT now(),
+    CONSTRAINT uk_skill_subscription UNIQUE (skill_id, user_id)
+);
+
+CREATE INDEX idx_skill_subscription_user ON skill_subscription(user_id, created_at DESC);
+CREATE INDEX idx_skill_subscription_skill ON skill_subscription(skill_id);
+
+-- Add subscription_count column to skill table
+ALTER TABLE skill ADD COLUMN subscription_count INTEGER NOT NULL DEFAULT 0;

server/skillhub-app/src/test/java/com/iflytek/skillhub/controller/ReviewPortalControllerTest.java

@@ -178,6 +178,7 @@ void getReviewSkillDetail_returnsReviewBoundPayload() throws Exception {
                                 "ACTIVE",
                                 8L,
                                 2,
+                                0,
                                 null,
                                 0,
                                 false,

server/skillhub-app/src/test/java/com/iflytek/skillhub/controller/SkillControllerTest.java

@@ -161,6 +161,7 @@ void getSkillDetailShouldExposePendingPreviewFlags() throws Exception {
                         "ACTIVE",
                         10L,
                         2,
+                        0,
                         null,
                         0,
                         false,

server/skillhub-app/src/test/java/com/iflytek/skillhub/controller/portal/SkillSubscriptionControllerTest.java

@@ -0,0 +1,134 @@
+package com.iflytek.skillhub.controller.portal;
+
+import com.iflytek.skillhub.auth.rbac.PlatformPrincipal;
+import com.iflytek.skillhub.domain.namespace.NamespaceMemberRepository;
+import com.iflytek.skillhub.domain.social.SkillSubscriptionService;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.authority.SimpleGrantedAuthority;
+import org.springframework.test.context.ActiveProfiles;
+import org.springframework.test.web.servlet.MockMvc;
+
+import java.util.List;
+import java.util.Set;
+
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.authentication;
+import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.csrf;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
+
+@SpringBootTest
+@AutoConfigureMockMvc
+@ActiveProfiles("test")
+class SkillSubscriptionControllerTest {
+
+    @Autowired
+    private MockMvc mockMvc;
+
+    @MockBean
+    private SkillSubscriptionService skillSubscriptionService;
+
+    @MockBean
+    private NamespaceMemberRepository namespaceMemberRepository;
+
+    private static UsernamePasswordAuthenticationToken authenticatedUser() {
+        PlatformPrincipal principal = new PlatformPrincipal(
+                "user-42",
+                "tester",
+                "tester@example.com",
+                "https://example.com/avatar.png",
+                "github",
+                Set.of("SUPER_ADMIN")
+        );
+        return new UsernamePasswordAuthenticationToken(
+                principal,
+                null,
+                List.of(new SimpleGrantedAuthority("ROLE_SUPER_ADMIN"))
+        );
+    }
+
+    // --- PUT /api/web/skills/{skillId}/subscription ---
+
+    @Test
+    void subscribe_skill_returns_envelope() throws Exception {
+        mockMvc.perform(put("/api/web/skills/10/subscription")
+                        .with(authentication(authenticatedUser())))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.code").value(0))
+                .andExpect(jsonPath("$.timestamp").isNotEmpty())
+                .andExpect(jsonPath("$.requestId").isNotEmpty());
+
+        verify(skillSubscriptionService).subscribe(eq(10L), eq("user-42"));
+    }
+
+    @Test
+    void subscribe_skill_unauthenticated_returns_401() throws Exception {
+        mockMvc.perform(put("/api/web/skills/10/subscription"))
+                .andExpect(status().isUnauthorized())
+                .andExpect(jsonPath("$.code").value(401));
+    }
+
+    // --- DELETE /api/web/skills/{skillId}/subscription ---
+
+    @Test
+    void unsubscribe_skill_returns_envelope() throws Exception {
+        mockMvc.perform(delete("/api/web/skills/10/subscription")
+                        .with(authentication(authenticatedUser())))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.code").value(0))
+                .andExpect(jsonPath("$.timestamp").isNotEmpty())
+                .andExpect(jsonPath("$.requestId").isNotEmpty());
+
+        verify(skillSubscriptionService).unsubscribe(eq(10L), eq("user-42"));
+    }
+
+    @Test
+    void unsubscribe_skill_unauthenticated_returns_401() throws Exception {
+        mockMvc.perform(delete("/api/web/skills/10/subscription"))
+                .andExpect(status().isUnauthorized())
+                .andExpect(jsonPath("$.code").value(401));
+    }
+
+    // --- GET /api/web/skills/{skillId}/subscription ---
+
+    @Test
+    void check_subscribed_returns_true() throws Exception {
+        when(skillSubscriptionService.isSubscribed(eq(10L), eq("user-42"))).thenReturn(true);
+
+        mockMvc.perform(get("/api/web/skills/10/subscription")
+                        .with(authentication(authenticatedUser())))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.code").value(0))
+                .andExpect(jsonPath("$.data").value(true))
+                .andExpect(jsonPath("$.timestamp").isNotEmpty())
+                .andExpect(jsonPath("$.requestId").isNotEmpty());
+    }
+
+    @Test
+    void check_subscribed_returns_false() throws Exception {
+        when(skillSubscriptionService.isSubscribed(eq(10L), eq("user-42"))).thenReturn(false);
+
+        mockMvc.perform(get("/api/web/skills/10/subscription")
+                        .with(authentication(authenticatedUser())))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.code").value(0))
+                .andExpect(jsonPath("$.data").value(false))
+                .andExpect(jsonPath("$.timestamp").isNotEmpty())
+                .andExpect(jsonPath("$.requestId").isNotEmpty());
+    }
+
+    @Test
+    void check_subscribed_unauthenticated_returns_false() throws Exception {
+        mockMvc.perform(get("/api/web/skills/10/subscription"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.code").value(0))
+                .andExpect(jsonPath("$.data").value(false));
+    }
+}