feat: add release plan collaboration and versioned diffs

pkg/cli/initconfig/cmd/init.go

@@ -187,6 +187,7 @@ func createOrUpdateMongodbIndex(ctx context.Context) {
 		commonrepo.NewLLMIntegrationColl(),
 		commonrepo.NewReleasePlanColl(),
 		commonrepo.NewReleasePlanLogColl(),
+		commonrepo.NewReleasePlanVersionColl(),
 		commonrepo.NewEnvServiceVersionColl(),
 		commonrepo.NewLabelColl(),
 		commonrepo.NewSprintTemplateColl(),

pkg/microservice/aslan/core/common/repository/models/release_plan.go

@@ -25,6 +25,7 @@ import (
 type ReleasePlan struct {
 	ID      primitive.ObjectID `bson:"_id,omitempty"       yaml:"-"                   json:"id"`
 	Index   int64              `bson:"index"       yaml:"index"                   json:"index"`
+	Version int64              `bson:"version"       yaml:"version"                   json:"version"`
 	Name    string             `bson:"name"       yaml:"name"                   json:"name"`
 	Manager string             `bson:"manager"       yaml:"manager"                   json:"manager"`
 	// ManagerID is the user id of the manager
@@ -120,19 +121,43 @@ type WorkflowReleaseJobSpec struct {
 }
 
 type ReleasePlanLog struct {
-	ID         primitive.ObjectID `bson:"_id,omitempty"               json:"id"`
-	PlanID     string             `bson:"plan_id"                     json:"plan_id"`
-	Username   string             `bson:"username"                    json:"username"`
-	Account    string             `bson:"account"                     json:"account"`
-	Verb       string             `bson:"verb"                        json:"verb"`
-	TargetName string             `bson:"target_name"                 json:"target_name"`
-	TargetType string             `bson:"target_type"                 json:"target_type"`
-	Before     interface{}        `bson:"before"                      json:"before"`
-	After      interface{}        `bson:"after"                       json:"after"`
-	Detail     string             `bson:"detail"                      json:"detail"`
-	CreatedAt  int64              `bson:"created_at"                  json:"created_at"`
+	ID          primitive.ObjectID `bson:"_id,omitempty"               json:"id"`
+	PlanID      string             `bson:"plan_id"                     json:"plan_id"`
+	Username    string             `bson:"username"                    json:"username"`
+	Account     string             `bson:"account"                     json:"account"`
+	Verb        string             `bson:"verb"                        json:"verb"`
+	TargetName  string             `bson:"target_name"                 json:"target_name"`
+	TargetType  string             `bson:"target_type"                 json:"target_type"`
+	Before      interface{}        `bson:"before,omitempty"            json:"before,omitempty"`
+	After       interface{}        `bson:"after,omitempty"             json:"after,omitempty"`
+	Detail      string             `bson:"detail"                      json:"detail"`
+	Version     int64              `bson:"version,omitempty"           json:"version,omitempty"`
+	SectionKey  string             `bson:"section_key,omitempty"       json:"section_key,omitempty"`
+	SectionName string             `bson:"section_name,omitempty"      json:"section_name,omitempty"`
+	SectionType string             `bson:"section_type,omitempty"      json:"section_type,omitempty"`
+	CreatedAt   int64              `bson:"created_at"                  json:"created_at"`
 }
 
 func (ReleasePlanLog) TableName() string {
 	return "release_plan_log"
 }
+
+type ReleasePlanVersion struct {
+	ID              primitive.ObjectID `bson:"_id,omitempty" json:"id"`
+	PlanID          string             `bson:"plan_id" json:"plan_id"`
+	Version         int64              `bson:"version" json:"version"`
+	PreviousVersion int64              `bson:"previous_version,omitempty" json:"previous_version,omitempty"`
+	Operator        string             `bson:"operator" json:"operator"`
+	Account         string             `bson:"account" json:"account"`
+	SectionKey      string             `bson:"section_key,omitempty" json:"section_key,omitempty"`
+	SectionName     string             `bson:"section_name,omitempty" json:"section_name,omitempty"`
+	SectionType     string             `bson:"section_type,omitempty" json:"section_type,omitempty"`
+	Verb            string             `bson:"verb,omitempty" json:"verb,omitempty"`
+	BaseSnapshot    interface{}        `bson:"base_snapshot,omitempty" json:"base_snapshot,omitempty"`
+	Snapshot        interface{}        `bson:"snapshot" json:"snapshot"`
+	CreatedAt       int64              `bson:"created_at" json:"created_at"`
+}
+
+func (ReleasePlanVersion) TableName() string {
+	return "release_plan_version"
+}

pkg/microservice/aslan/core/common/repository/mongodb/release_plan.go

@@ -79,19 +79,34 @@ func (c *ReleasePlanColl) EnsureIndex(ctx context.Context) error {
 			Keys:    bson.M{"update_time": 1},
 			Options: options.Index().SetUnique(false),
 		},
+		{
+			Keys:    bson.M{"version": 1},
+			Options: options.Index().SetUnique(false),
+		},
 	}
 
 	_, err := c.Indexes().CreateMany(ctx, mod, mongotool.CreateIndexOptions(ctx))
 	return err
 }
 
 func (c *ReleasePlanColl) Create(args *models.ReleasePlan) (string, error) {
+	return c.CreateWithCtx(context.Background(), args)
+}
+
+func (c *ReleasePlanColl) CreateWithCtx(ctx context.Context, args *models.ReleasePlan) (string, error) {
 	if args == nil {
 		return "", errors.New("nil ReleasePlan")
 	}
 
-	res, err := c.InsertOne(context.Background(), args)
-	return res.InsertedID.(primitive.ObjectID).Hex(), err
+	res, err := c.InsertOne(ctx, args)
+	if err != nil {
+		return "", err
+	}
+	id, ok := res.InsertedID.(primitive.ObjectID)
+	if !ok {
+		return "", errors.New("invalid ReleasePlan inserted id")
+	}
+	return id.Hex(), nil
 }
 
 func (c *ReleasePlanColl) GetByID(ctx context.Context, idString string) (*models.ReleasePlan, error) {

pkg/microservice/aslan/core/common/repository/mongodb/release_plan_log.go

@@ -48,7 +48,14 @@ func (c *ReleasePlanLogColl) GetCollectionName() string {
 }
 
 func (c *ReleasePlanLogColl) EnsureIndex(ctx context.Context) error {
-	return nil
+	mod := []mongo.IndexModel{
+		{
+			Keys: bson.D{{Key: "plan_id", Value: 1}, {Key: "created_at", Value: -1}},
+		},
+	}
+
+	_, err := c.Indexes().CreateMany(ctx, mod, mongotool.CreateIndexOptions(ctx))
+	return err
 }
 
 func (c *ReleasePlanLogColl) Create(args *models.ReleasePlanLog) error {
@@ -76,7 +83,7 @@ func (c *ReleasePlanLogColl) ListByOptions(opt *ListReleasePlanLogOption) ([]*mo
 	ctx := context.Background()
 	opts := options.Find()
 	if opt.IsSort {
-		opts.SetSort(bson.D{{"create_time", -1}})
+		opts.SetSort(bson.D{{"created_at", -1}})
 	}
 	if opt.PlanID != "" {
 		query["plan_id"] = opt.PlanID

pkg/microservice/aslan/core/common/repository/mongodb/release_plan_version.go

@@ -0,0 +1,113 @@
+/*
+ * Copyright 2026 The KodeRover Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package mongodb
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+
+	"github.com/koderover/zadig/v2/pkg/microservice/aslan/config"
+	"github.com/koderover/zadig/v2/pkg/microservice/aslan/core/common/repository/models"
+	mongotool "github.com/koderover/zadig/v2/pkg/tool/mongo"
+)
+
+type ReleasePlanVersionColl struct {
+	*mongo.Collection
+
+	coll string
+}
+
+func NewReleasePlanVersionColl() *ReleasePlanVersionColl {
+	name := models.ReleasePlanVersion{}.TableName()
+	return &ReleasePlanVersionColl{
+		Collection: mongotool.Database(config.MongoDatabase()).Collection(name),
+		coll:       name,
+	}
+}
+
+func (c *ReleasePlanVersionColl) GetCollectionName() string {
+	return c.coll
+}
+
+func (c *ReleasePlanVersionColl) EnsureIndex(ctx context.Context) error {
+	mod := []mongo.IndexModel{
+		{
+			Keys:    bson.D{{Key: "plan_id", Value: 1}, {Key: "version", Value: 1}},
+			Options: options.Index().SetUnique(true),
+		},
+		{
+			Keys: bson.D{{Key: "plan_id", Value: 1}, {Key: "created_at", Value: -1}},
+		},
+	}
+
+	_, err := c.Indexes().CreateMany(ctx, mod, mongotool.CreateIndexOptions(ctx))
+	return err
+}
+
+func (c *ReleasePlanVersionColl) CreateWithCtx(ctx context.Context, args *models.ReleasePlanVersion) error {
+	if args == nil {
+		return errors.New("nil ReleasePlanVersion")
+	}
+
+	_, err := c.InsertOne(ctx, args)
+	return err
+}
+
+func (c *ReleasePlanVersionColl) UpsertWithCtx(ctx context.Context, args *models.ReleasePlanVersion) error {
+	if args == nil {
+		return errors.New("nil ReleasePlanVersion")
+	}
+
+	_, err := c.ReplaceOne(ctx, bson.M{
+		"plan_id": args.PlanID,
+		"version": args.Version,
+	}, args, options.Replace().SetUpsert(true))
+	return err
+}
+
+func (c *ReleasePlanVersionColl) DeleteWithCtx(ctx context.Context, planID string, version int64) error {
+	_, err := c.DeleteOne(ctx, bson.M{
+		"plan_id": planID,
+		"version": version,
+	})
+	return err
+}
+
+func (c *ReleasePlanVersionColl) Get(planID string, version int64) (*models.ReleasePlanVersion, error) {
+	resp := new(models.ReleasePlanVersion)
+	err := c.FindOne(context.Background(), bson.M{
+		"plan_id": planID,
+		"version": version,
+	}).Decode(resp)
+	return resp, err
+}
+
+func (c *ReleasePlanVersionColl) GetLatestBySectionsBefore(planID string, sectionKeys []string, beforeVersion int64) (*models.ReleasePlanVersion, error) {
+	resp := new(models.ReleasePlanVersion)
+	err := c.FindOne(context.Background(), bson.M{
+		"plan_id": planID,
+		"version": bson.M{"$lt": beforeVersion},
+		"section_key": bson.M{
+			"$in": sectionKeys,
+		},
+	}, options.FindOne().SetSort(bson.D{{Key: "version", Value: -1}})).Decode(resp)
+	return resp, err
+}

pkg/microservice/aslan/core/release_plan/handler/openapi.go

@@ -159,5 +159,5 @@ func OpenAPIUpdateReleasePlanWithJobs(c *gin.Context) {
 		return
 	}
 
-	ctx.RespErr = service.OpenAPICreateReleasePlanWithJobs(ctx, c.Param("id"), opt)
+	ctx.RespErr = service.OpenAPIUpdateReleasePlanWithJobs(ctx, c.Param("id"), opt)
 }

pkg/microservice/aslan/core/release_plan/handler/release_plan.go

@@ -18,6 +18,7 @@ package handler
 
 import (
 	"fmt"
+	"strconv"
 	"strings"
 
 	"github.com/gin-gonic/gin"
@@ -78,6 +79,56 @@ func GetReleasePlanLogs(c *gin.Context) {
 	ctx.Resp, ctx.RespErr = service.GetReleasePlanLogs(c.Param("id"))
 }
 
+func GetReleasePlanCollaborationSnapshot(c *gin.Context) {
+	ctx, err := internalhandler.NewContextWithAuthorization(c)
+	defer func() { internalhandler.JSONResponse(c, ctx) }()
+
+	if err != nil {
+		ctx.Logger.Errorf("failed to generate authorization info for user: %s, error: %s", ctx.UserID, err)
+		ctx.RespErr = fmt.Errorf("authorization Info Generation failed: err %s", err)
+		ctx.UnAuthorized = true
+		return
+	}
+
+	if !ctx.Resources.IsSystemAdmin && !ctx.Resources.SystemActions.ReleasePlan.View {
+		ctx.UnAuthorized = true
+		return
+	}
+
+	err = commonutil.CheckZadigEnterpriseLicense()
+	if err != nil {
+		ctx.RespErr = err
+		return
+	}
+
+	ctx.Resp, ctx.RespErr = service.GetReleasePlanCollaborationSnapshot(c.Param("id"))
+}
+
+func ReleasePlanCollaborationWS(c *gin.Context) {
+	ctx, err := internalhandler.NewContextWithAuthorization(c)
+	defer func() { internalhandler.JSONResponse(c, ctx) }()
+
+	if err != nil {
+		ctx.Logger.Errorf("failed to generate authorization info for user: %s, error: %s", ctx.UserID, err)
+		ctx.RespErr = fmt.Errorf("authorization Info Generation failed: err %s", err)
+		ctx.UnAuthorized = true
+		return
+	}
+
+	if !ctx.Resources.IsSystemAdmin && !ctx.Resources.SystemActions.ReleasePlan.View {
+		ctx.UnAuthorized = true
+		return
+	}
+
+	err = commonutil.CheckZadigEnterpriseLicense()
+	if err != nil {
+		ctx.RespErr = err
+		return
+	}
+
+	ctx.RespErr = service.OpenReleasePlanCollaborationWS(c, ctx, c.Param("id"))
+}
+
 func CreateReleasePlan(c *gin.Context) {
 	ctx, err := internalhandler.NewContextWithAuthorization(c)
 	defer func() { internalhandler.JSONResponse(c, ctx) }()
@@ -189,6 +240,36 @@ func UpdateReleasePlan(c *gin.Context) {
 	ctx.RespErr = service.UpdateReleasePlan(ctx, c.Param("id"), req)
 }
 
+func GetReleasePlanVersionDiff(c *gin.Context) {
+	ctx, err := internalhandler.NewContextWithAuthorization(c)
+	defer func() { internalhandler.JSONResponse(c, ctx) }()
+
+	if err != nil {
+		ctx.RespErr = fmt.Errorf("authorization Info Generation failed: err %s", err)
+		ctx.UnAuthorized = true
+		return
+	}
+
+	if !ctx.Resources.IsSystemAdmin && !ctx.Resources.SystemActions.ReleasePlan.View {
+		ctx.UnAuthorized = true
+		return
+	}
+
+	err = commonutil.CheckZadigEnterpriseLicense()
+	if err != nil {
+		ctx.RespErr = err
+		return
+	}
+
+	version, err := strconv.ParseInt(c.Param("version"), 10, 64)
+	if err != nil {
+		ctx.RespErr = e.ErrInvalidParam.AddDesc(err.Error())
+		return
+	}
+
+	ctx.Resp, ctx.RespErr = service.GetReleasePlanVersionDiff(c.Param("id"), version)
+}
+
 func GetReleasePlanJobDetail(c *gin.Context) {
 	ctx, err := internalhandler.NewContextWithAuthorization(c)
 	defer func() { internalhandler.JSONResponse(c, ctx) }()

pkg/microservice/aslan/core/release_plan/handler/router.go

@@ -28,7 +28,10 @@ func (*Router) Inject(router *gin.RouterGroup) {
 		v1.POST("/:id/copy", CopyReleasePlan)
 		v1.GET("/:id", GetReleasePlan)
 		v1.GET("/:id/logs", GetReleasePlanLogs)
+		v1.GET("/:id/collaboration/editors", GetReleasePlanCollaborationSnapshot)
+		v1.GET("/:id/collaboration/ws", ReleasePlanCollaborationWS)
 		v1.PUT("/:id", UpdateReleasePlan)
+		v1.GET("/:id/versions/:version/diff", GetReleasePlanVersionDiff)
 		v1.GET("/:id/job/:jobID", GetReleasePlanJobDetail)
 		v1.DELETE("/:id", DeleteReleasePlan)