feat(core): implement scoped revertible effects for context extpoints

backend/core/scoped_extpoints.go

@@ -0,0 +1,201 @@
+// Copyright 2026 Arctel.net
+// SPDX-License-Identifier: Apache-2.0
+
+package core
+
+import (
+	"Wavelet/core/extpoints"
+)
+
+// scopedRouterExtension wraps a RouterExtension to automatically register
+// teardown disposers on the associated Context when routes are declared.
+type scopedRouterExtension struct {
+	underlying extpoints.RouterExtension
+	ctx        *Context
+}
+
+func newScopedRouterExtension(ctx *Context, underlying extpoints.RouterExtension) extpoints.RouterExtension {
+	return &scopedRouterExtension{
+		underlying: underlying,
+		ctx:        ctx,
+	}
+}
+
+func (s *scopedRouterExtension) Use(middlewares ...any) {
+	s.underlying.Use(middlewares...)
+}
+
+func (s *scopedRouterExtension) Group(prefix string, middlewares ...any) extpoints.RouterExtension {
+	subGroup := s.underlying.Group(prefix, middlewares...)
+	return newScopedRouterExtension(s.ctx, subGroup)
+}
+
+func (s *scopedRouterExtension) Handle(method string, path string, handlers ...any) extpoints.RouteDefinition {
+	rd := s.underlying.Handle(method, path, handlers...)
+	routeID := rd.ID
+	s.ctx.OnDispose(func() error {
+		s.underlying.UnregisterByID(routeID)
+		return nil
+	})
+	return rd
+}
+
+func (s *scopedRouterExtension) GET(path string, handlers ...any) extpoints.RouteDefinition {
+	return s.Handle("GET", path, handlers...)
+}
+
+func (s *scopedRouterExtension) POST(path string, handlers ...any) extpoints.RouteDefinition {
+	return s.Handle("POST", path, handlers...)
+}
+
+func (s *scopedRouterExtension) PUT(path string, handlers ...any) extpoints.RouteDefinition {
+	return s.Handle("PUT", path, handlers...)
+}
+
+func (s *scopedRouterExtension) DELETE(path string, handlers ...any) extpoints.RouteDefinition {
+	return s.Handle("DELETE", path, handlers...)
+}
+
+func (s *scopedRouterExtension) PATCH(path string, handlers ...any) extpoints.RouteDefinition {
+	return s.Handle("PATCH", path, handlers...)
+}
+
+func (s *scopedRouterExtension) HEAD(path string, handlers ...any) extpoints.RouteDefinition {
+	return s.Handle("HEAD", path, handlers...)
+}
+
+func (s *scopedRouterExtension) OPTIONS(path string, handlers ...any) extpoints.RouteDefinition {
+	return s.Handle("OPTIONS", path, handlers...)
+}
+
+func (s *scopedRouterExtension) Any(path string, handlers ...any) []extpoints.RouteDefinition {
+	methods := []string{"GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"}
+	defs := make([]extpoints.RouteDefinition, 0, len(methods))
+	for _, m := range methods {
+		defs = append(defs, s.Handle(m, path, handlers...))
+	}
+	return defs
+}
+
+func (s *scopedRouterExtension) Routes() []extpoints.RouteDefinition {
+	return s.underlying.Routes()
+}
+
+func (s *scopedRouterExtension) Middlewares() []any {
+	return s.underlying.Middlewares()
+}
+
+func (s *scopedRouterExtension) Unregister(method, path string) bool {
+	return s.underlying.Unregister(method, path)
+}
+
+func (s *scopedRouterExtension) UnregisterByID(id uint64) bool {
+	return s.underlying.UnregisterByID(id)
+}
+
+// scopedTaskExtension wraps a TaskExtension to automatically register
+// teardown disposers on the associated Context when task handlers are declared.
+type scopedTaskExtension struct {
+	underlying extpoints.TaskExtension
+	ctx        *Context
+}
+
+func newScopedTaskExtension(ctx *Context, underlying extpoints.TaskExtension) extpoints.TaskExtension {
+	return &scopedTaskExtension{
+		underlying: underlying,
+		ctx:        ctx,
+	}
+}
+
+func (s *scopedTaskExtension) Register(pattern string, handler any, opts ...extpoints.TaskOption) {
+	s.underlying.Register(pattern, handler, opts...)
+	s.ctx.OnDispose(func() error {
+		s.underlying.Unregister(pattern)
+		return nil
+	})
+}
+
+func (s *scopedTaskExtension) Tasks() []extpoints.TaskDefinition {
+	return s.underlying.Tasks()
+}
+
+func (s *scopedTaskExtension) Get(pattern string) (extpoints.TaskDefinition, bool) {
+	return s.underlying.Get(pattern)
+}
+
+func (s *scopedTaskExtension) Unregister(pattern string) bool {
+	return s.underlying.Unregister(pattern)
+}
+
+// scopedScheduleExtension wraps a ScheduleExtension to automatically register
+// teardown disposers on the associated Context when cron/scheduled tasks are declared.
+type scopedScheduleExtension struct {
+	underlying extpoints.ScheduleExtension
+	ctx        *Context
+}
+
+func newScopedScheduleExtension(ctx *Context, underlying extpoints.ScheduleExtension) extpoints.ScheduleExtension {
+	return &scopedScheduleExtension{
+		underlying: underlying,
+		ctx:        ctx,
+	}
+}
+
+func (s *scopedScheduleExtension) Register(spec string, taskType string, payload any, opts ...extpoints.ScheduleOption) {
+	s.underlying.Register(spec, taskType, payload, opts...)
+	s.ctx.OnDispose(func() error {
+		s.underlying.Unregister(taskType)
+		return nil
+	})
+}
+
+func (s *scopedScheduleExtension) RegisterCron(spec string, taskType string, payload any, opts ...extpoints.ScheduleOption) {
+	s.Register(spec, taskType, payload, opts...)
+}
+
+func (s *scopedScheduleExtension) Schedules() []extpoints.ScheduleDefinition {
+	return s.underlying.Schedules()
+}
+
+func (s *scopedScheduleExtension) Get(taskType string) (extpoints.ScheduleDefinition, bool) {
+	return s.underlying.Get(taskType)
+}
+
+func (s *scopedScheduleExtension) Unregister(taskType string) bool {
+	return s.underlying.Unregister(taskType)
+}
+
+// scopedSettingExtension wraps a SettingExtension to automatically register
+// teardown disposers on the associated Context when settings schemas are declared.
+type scopedSettingExtension struct {
+	underlying extpoints.SettingExtension
+	ctx        *Context
+}
+
+func newScopedSettingExtension(ctx *Context, underlying extpoints.SettingExtension) extpoints.SettingExtension {
+	return &scopedSettingExtension{
+		underlying: underlying,
+		ctx:        ctx,
+	}
+}
+
+func (s *scopedSettingExtension) Register(schema extpoints.SettingSchema) {
+	s.underlying.Register(schema)
+	key := schema.Key
+	s.ctx.OnDispose(func() error {
+		s.underlying.Unregister(key)
+		return nil
+	})
+}
+
+func (s *scopedSettingExtension) Schemas() []extpoints.SettingSchema {
+	return s.underlying.Schemas()
+}
+
+func (s *scopedSettingExtension) Get(key string) (extpoints.SettingSchema, bool) {
+	return s.underlying.Get(key)
+}
+
+func (s *scopedSettingExtension) Unregister(key string) bool {
+	return s.underlying.Unregister(key)
+}