Enhance repo creation (#570)

pulltheflower · web-flow · commit 05c81a550ec1 · 2025-12-08T21:32:43.000+08:00
diff --git a/_mocks/opencsg.com/csghub-server/component/mock_RepoComponent.go b/_mocks/opencsg.com/csghub-server/component/mock_RepoComponent.go
diff --git a/component/code.go b/component/code.go
@@ -93,7 +93,7 @@ func (c *codeComponentImpl) Create(ctx context.Context, req *types.CreateCodeReq
 			Path:    types.GitattributesFileName,
 		},
 	}
-	_, dbRepo, err := c.repoComponent.CreateRepo(ctx, req.CreateRepoReq)
+	_, dbRepo, commitFilesReq, err := c.repoComponent.CreateRepo(ctx, req.CreateRepoReq)
 	if err != nil {
 		return nil, err
 	}
@@ -109,6 +109,8 @@ func (c *codeComponentImpl) Create(ctx context.Context, req *types.CreateCodeReq
 		return nil, fmt.Errorf("failed to create database code, cause: %w", err)
 	}
 
+	_ = c.gitServer.CommitFiles(ctx, *commitFilesReq)
+
 	for _, tag := range code.Repository.Tags {
 		tags = append(tags, types.RepoTag{
 			Name:      tag.Name,
diff --git a/component/code_test.go b/component/code_test.go
@@ -8,6 +8,7 @@ import (
 	"github.com/stretchr/testify/mock"
 
 	"github.com/stretchr/testify/require"
+	"opencsg.com/csghub-server/builder/git/gitserver"
 	"opencsg.com/csghub-server/builder/git/membership"
 	"opencsg.com/csghub-server/builder/store/database"
 	"opencsg.com/csghub-server/common/types"
@@ -62,8 +63,9 @@ func TestCodeComponent_Create(t *testing.T) {
 			return nil
 		}).Once()
 	cc.mocks.components.repo.EXPECT().CreateRepo(ctx, crq).Return(
-		nil, dbrepo, nil,
+		nil, dbrepo, &gitserver.CommitFilesReq{}, nil,
 	)
+	cc.mocks.gitServer.EXPECT().CommitFiles(ctx, gitserver.CommitFilesReq{}).Return(nil)
 	cc.mocks.stores.CodeMock().EXPECT().CreateAndUpdateRepoPath(ctx, database.Code{
 		Repository:   dbrepo,
 		RepositoryID: 1,
diff --git a/component/dataset.go b/component/dataset.go
@@ -128,7 +128,7 @@ func (c *datasetComponentImpl) Create(ctx context.Context, req *types.CreateData
 			Path:    types.GitattributesFileName,
 		},
 	}
-	_, dbRepo, err := c.repoComponent.CreateRepo(ctx, req.CreateRepoReq)
+	_, dbRepo, commitFilesReq, err := c.repoComponent.CreateRepo(ctx, req.CreateRepoReq)
 	if err != nil {
 		return nil, err
 	}
@@ -144,6 +144,8 @@ func (c *datasetComponentImpl) Create(ctx context.Context, req *types.CreateData
 		return nil, fmt.Errorf("failed to create database dataset, cause: %w", err)
 	}
 
+	_ = c.gitServer.CommitFiles(ctx, *commitFilesReq)
+
 	for _, tag := range dataset.Repository.Tags {
 		tags = append(tags, types.RepoTag{
 			Name:      tag.Name,
diff --git a/component/dataset_test.go b/component/dataset_test.go
@@ -53,8 +53,9 @@ func TestDatasetCompnent_Create(t *testing.T) {
 	dc.mocks.components.repo.EXPECT().CreateRepo(ctx, rq).Return(&gitserver.CreateRepoResp{}, &database.Repository{
 		Tags: []database.Tag{{Name: "t1"}},
 		User: database.User{UUID: "user-uuid"},
-	}, nil)
+	}, &gitserver.CommitFilesReq{}, nil)
 
+	dc.mocks.gitServer.EXPECT().CommitFiles(ctx, gitserver.CommitFilesReq{}).Return(nil)
 	dc.mocks.stores.DatasetMock().EXPECT().CreateAndUpdateRepoPath(ctx, mock.Anything, "ns/n").RunAndReturn(
 		func(ctx context.Context, ds database.Dataset, _ string) (*database.Dataset, error) {
 			require.NotNil(t, ds.Repository)
diff --git a/component/mcp_server.go b/component/mcp_server.go
@@ -103,7 +103,7 @@ func (m *mcpServerComponentImpl) Create(ctx context.Context, req *types.CreateMC
 			Path:    types.ReadmeFileName,
 		},
 	}
-	_, dbRepo, err := m.repoComponent.CreateRepo(ctx, req.CreateRepoReq)
+	_, dbRepo, commitFilesReq, err := m.repoComponent.CreateRepo(ctx, req.CreateRepoReq)
 	if err != nil {
 		return nil, fmt.Errorf("fail to create mcp repo cause: %w", err)
 	}
@@ -120,6 +120,8 @@ func (m *mcpServerComponentImpl) Create(ctx context.Context, req *types.CreateMC
 		return nil, fmt.Errorf("fail to create mcp server cause: %w", err)
 	}
 
+	_ = m.gitServer.CommitFiles(ctx, *commitFilesReq)
+
 	for _, tag := range mcpServer.Repository.Tags {
 		tags = append(tags, types.RepoTag{
 			Name:      tag.Name,
diff --git a/component/mcp_server_test.go b/component/mcp_server_test.go
@@ -61,7 +61,9 @@ func TestMCPServerComponent_Create(t *testing.T) {
 				Path:    types.ReadmeFileName,
 			},
 		},
-	}).Return(nil, dbrepo, nil)
+	}).Return(nil, dbrepo, &gitserver.CommitFilesReq{}, nil)
+
+	mc.mocks.gitServer.EXPECT().CommitFiles(ctx, gitserver.CommitFilesReq{}).Return(nil)
 
 	mc.mocks.stores.MCPServerMock().EXPECT().CreateAndUpdateRepoPath(ctx, database.MCPServer{
 		RepositoryID:  dbrepo.ID,
diff --git a/component/mirror.go b/component/mirror.go
@@ -167,7 +167,7 @@ func (c *mirrorComponentImpl) CreateMirrorRepo(ctx context.Context, req types.Cr
 	username = dbNamespace.User.Username
 
 	// create repo, create mirror repo
-	_, repo, err = c.repoComp.CreateRepo(ctx, types.CreateRepoReq{
+	_, repo, _, err = c.repoComp.CreateRepo(ctx, types.CreateRepoReq{
 		Username:  username,
 		Namespace: namespace,
 		Name:      name,
diff --git a/component/mirror_test.go b/component/mirror_test.go
@@ -63,7 +63,7 @@ func TestMirrorComponent_CreateMirrorRepo(t *testing.T) {
 			}, nil)
 
 			repo1 := &database.Repository{ID: 11}
-			mc.mocks.components.repo.EXPECT().CreateRepo(ctx, mock.AnythingOfType("types.CreateRepoReq")).Return(&gitserver.CreateRepoResp{}, repo1, nil)
+			mc.mocks.components.repo.EXPECT().CreateRepo(ctx, mock.AnythingOfType("types.CreateRepoReq")).Return(&gitserver.CreateRepoResp{}, repo1, &gitserver.CommitFilesReq{}, nil)
 			switch req.RepoType {
 			case types.ModelRepo:
 				mc.mocks.stores.ModelMock().EXPECT().CreateAndUpdateRepoPath(ctx, database.Model{
diff --git a/component/model.go b/component/model.go
@@ -267,7 +267,7 @@ func (c *modelComponentImpl) Create(ctx context.Context, req *types.CreateModelR
 			Path:    types.GitattributesFileName,
 		},
 	}
-	_, dbRepo, err := c.repoComponent.CreateRepo(ctx, req.CreateRepoReq)
+	_, dbRepo, commitFilesReq, err := c.repoComponent.CreateRepo(ctx, req.CreateRepoReq)
 	if err != nil {
 		return nil, err
 	}
@@ -287,6 +287,8 @@ func (c *modelComponentImpl) Create(ctx context.Context, req *types.CreateModelR
 		return nil, fmt.Errorf("failed to create database model, cause: %w", err)
 	}
 
+	_ = c.gitServer.CommitFiles(ctx, *commitFilesReq)
+
 	for _, tag := range model.Repository.Tags {
 		tags = append(tags, types.RepoTag{
 			Name:      tag.Name,
diff --git a/component/model_test.go b/component/model_test.go
@@ -93,7 +93,9 @@ func TestModelComponent_Create(t *testing.T) {
 				Path:    types.GitattributesFileName,
 			},
 		},
-	}).Return(nil, dbrepo, nil)
+	}).Return(nil, dbrepo, &gitserver.CommitFilesReq{}, nil)
+
+	mc.mocks.gitServer.EXPECT().CommitFiles(ctx, gitserver.CommitFilesReq{}).Return(nil)
 
 	mc.mocks.stores.ModelMock().EXPECT().CreateAndUpdateRepoPath(ctx, database.Model{
 		Repository:   dbrepo,
diff --git a/component/prompt.go b/component/prompt.go
@@ -651,7 +651,7 @@ func (c *promptComponentImpl) CreatePromptRepo(ctx context.Context, req *types.C
 			Path:    types.GitattributesFileName,
 		},
 	}
-	_, dbRepo, err := c.repoComponent.CreateRepo(ctx, req.CreateRepoReq)
+	_, dbRepo, commitFilesReq, err := c.repoComponent.CreateRepo(ctx, req.CreateRepoReq)
 	if err != nil {
 		return nil, err
 	}
@@ -667,6 +667,8 @@ func (c *promptComponentImpl) CreatePromptRepo(ctx context.Context, req *types.C
 		return nil, fmt.Errorf("failed to create database prompt, cause: %w", err)
 	}
 
+	_ = c.gitServer.CommitFiles(ctx, *commitFilesReq)
+
 	for _, tag := range prompt.Repository.Tags {
 		tags = append(tags, types.RepoTag{
 			Name:      tag.Name,
diff --git a/component/prompt_test.go b/component/prompt_test.go
@@ -528,7 +528,9 @@ func TestPromptComponent_CreatePromptRepo(t *testing.T) {
 		},
 		Path: "ns/n",
 	}
-	pc.mocks.components.repo.EXPECT().CreateRepo(ctx, req).Return(&gitserver.CreateRepoResp{}, dbRepo, nil)
+	pc.mocks.components.repo.EXPECT().CreateRepo(ctx, req).Return(&gitserver.CreateRepoResp{}, dbRepo, &gitserver.CommitFilesReq{}, nil)
+
+	pc.mocks.gitServer.EXPECT().CommitFiles(ctx, gitserver.CommitFilesReq{}).Return(nil)
 
 	dbPrompt := database.Prompt{
 		Repository:   dbRepo,
diff --git a/component/repo.go b/component/repo.go
@@ -101,7 +101,7 @@ type repoComponentImpl struct {
 }
 
 type RepoComponent interface {
-	CreateRepo(ctx context.Context, req types.CreateRepoReq) (*gitserver.CreateRepoResp, *database.Repository, error)
+	CreateRepo(ctx context.Context, req types.CreateRepoReq) (*gitserver.CreateRepoResp, *database.Repository, *gitserver.CommitFilesReq, error)
 	UpdateRepo(ctx context.Context, req types.UpdateRepoReq) (*database.Repository, error)
 	DeleteRepo(ctx context.Context, req types.DeleteRepoReq) (*database.Repository, error)
 	// PublicToUser gets visible repos of the given user and user's orgs
@@ -201,39 +201,40 @@ func NewRepoComponentImpl(config *config.Config) (*repoComponentImpl, error) {
 	return r.(*repoComponentImpl), nil
 }
 
-func (c *repoComponentImpl) CreateRepo(ctx context.Context, req types.CreateRepoReq) (*gitserver.CreateRepoResp, *database.Repository, error) {
+func (c *repoComponentImpl) CreateRepo(ctx context.Context, req types.CreateRepoReq) (*gitserver.CreateRepoResp, *database.Repository, *gitserver.CommitFilesReq, error) {
+	var commitFilesReq *gitserver.CommitFilesReq
 	// Name validation
 	valid, err := common.IsValidName(req.Name)
 	if !valid {
-		return nil, nil, fmt.Errorf("repo name is invalid, error: %w", err)
+		return nil, nil, commitFilesReq, fmt.Errorf("repo name is invalid, error: %w", err)
 	}
 
 	namespace, err := c.namespaceStore.FindByPath(ctx, req.Namespace)
 	if err != nil {
-		return nil, nil, errors.New("namespace does not exist")
+		return nil, nil, commitFilesReq, errors.New("namespace does not exist")
 	}
 
 	user, err := c.userStore.FindByUsername(ctx, req.Username)
 	if err != nil {
-		return nil, nil, errors.New("user does not exist")
+		return nil, nil, commitFilesReq, errors.New("user does not exist")
 	}
 
 	if user.Email == "" {
-		return nil, nil, fmt.Errorf("please set your email first")
+		return nil, nil, commitFilesReq, fmt.Errorf("please set your email first")
 	}
 
 	if !user.CanAdmin() {
 		if namespace.NamespaceType == database.OrgNamespace {
 			canWrite, err := c.CheckCurrentUserPermission(ctx, req.Username, req.Namespace, membership.RoleWrite)
 			if err != nil {
-				return nil, nil, err
+				return nil, nil, commitFilesReq, err
 			}
 			if !canWrite {
-				return nil, nil, errorx.ErrForbiddenMsg("users do not have permission to create repo in this organization")
+				return nil, nil, commitFilesReq, errorx.ErrForbiddenMsg("users do not have permission to create repo in this organization")
 			}
 		} else {
 			if namespace.Path != user.Username {
-				return nil, nil, errorx.ErrForbiddenMsg("users do not have permission to create repo in this namespace")
+				return nil, nil, commitFilesReq, errorx.ErrForbiddenMsg("users do not have permission to create repo in this namespace")
 			}
 		}
 	}
@@ -260,7 +261,7 @@ func (c *repoComponentImpl) CreateRepo(ctx context.Context, req types.CreateRepo
 	}
 	newDBRepo, err := c.repoStore.CreateRepo(ctx, dbRepo)
 	if err != nil {
-		return nil, nil, fmt.Errorf("fail to create database repo, error: %w", err)
+		return nil, nil, commitFilesReq, fmt.Errorf("fail to create database repo, error: %w", err)
 	}
 
 	err = c.recomStore.UpsertScore(ctx, []*database.RecomRepoScore{
@@ -271,7 +272,7 @@ func (c *repoComponentImpl) CreateRepo(ctx context.Context, req types.CreateRepo
 		},
 	})
 	if err != nil {
-		return nil, nil, fmt.Errorf("fail to upsert recom repo score, error: %w", err)
+		return nil, nil, commitFilesReq, fmt.Errorf("fail to upsert recom repo score, error: %w", err)
 	}
 
 	gitRepoReq := gitserver.CreateRepoReq{
@@ -289,7 +290,7 @@ func (c *repoComponentImpl) CreateRepo(ctx context.Context, req types.CreateRepo
 	gitRepo, err := c.git.CreateRepo(ctx, gitRepoReq)
 	if err != nil {
 		slog.Error("fail to create repo in git ", slog.Any("req", req), slog.String("error", err.Error()))
-		return nil, nil, fmt.Errorf("fail to create repo in git, error: %w", err)
+		return nil, nil, commitFilesReq, fmt.Errorf("fail to create repo in git, error: %w", err)
 	}
 
 	if len(req.CommitFiles) > 0 {
@@ -301,22 +302,19 @@ func (c *repoComponentImpl) CreateRepo(ctx context.Context, req types.CreateRepo
 				Action:  gitserver.CommitActionCreate,
 			})
 		}
-		err = c.git.CommitFiles(ctx, gitserver.CommitFilesReq{
-			Namespace: temPath[0],
-			Name:      temPath[1],
+		commitFilesReq = &gitserver.CommitFilesReq{
+			Namespace: req.Namespace,
+			Name:      req.Name,
 			RepoType:  req.RepoType,
 			Revision:  req.DefaultBranch,
 			Username:  user.Username,
 			Email:     user.Email,
 			Message:   types.InitCommitMessage,
 			Files:     gitCommitFiles,
-		})
-		if err != nil {
-			return gitRepo, newDBRepo, fmt.Errorf("fail to commit files, error: %w", err)
 		}
 	}
 
-	return gitRepo, newDBRepo, nil
+	return gitRepo, newDBRepo, commitFilesReq, nil
 }
 
 func (c *repoComponentImpl) UpdateRepo(ctx context.Context, req types.UpdateRepoReq) (*database.Repository, error) {
diff --git a/component/repo_test.go b/component/repo_test.go
@@ -50,7 +50,6 @@ func TestRepoComponent_CreateRepo(t *testing.T) {
 	}
 	repo.mocks.stores.RecomMock().EXPECT().UpsertScore(ctx, mock.Anything).Return(nil)
 	repo.mocks.gitServer.EXPECT().CreateRepo(ctx, mock.AnythingOfType("gitserver.CreateRepoReq")).Return(gitrepo, nil)
-	repo.mocks.gitServer.EXPECT().CommitFiles(ctx, mock.AnythingOfType("gitserver.CommitFilesReq")).Return(nil)
 	dbrepo := &database.Repository{
 		UserID:         123,
 		Path:           "ns/name",
@@ -64,7 +63,7 @@ func TestRepoComponent_CreateRepo(t *testing.T) {
 		RepositoryType: types.ModelRepo,
 	}
 	repo.mocks.stores.RepoMock().EXPECT().CreateRepo(ctx, mock.AnythingOfType("database.Repository")).Return(dbrepo, nil)
-	r1, r2, err := repo.CreateRepo(ctx, types.CreateRepoReq{
+	r1, r2, _, err := repo.CreateRepo(ctx, types.CreateRepoReq{
 		Username:      "user",
 		Namespace:     "ns",
 		Name:          "name",
diff --git a/component/space.go b/component/space.go
@@ -94,7 +94,7 @@ func (c *spaceComponentImpl) Create(ctx context.Context, req types.CreateSpaceRe
 		}
 	}
 
-	_, dbRepo, err := c.repoComponent.CreateRepo(ctx, req.CreateRepoReq)
+	_, dbRepo, commitFilesReq, err := c.repoComponent.CreateRepo(ctx, req.CreateRepoReq)
 	if err != nil {
 		return nil, err
 	}
@@ -122,6 +122,7 @@ func (c *spaceComponentImpl) Create(ctx context.Context, req types.CreateSpaceRe
 		slog.Error("failed to create new space in db", slog.Any("req", req), slog.String("error", err.Error()))
 		return nil, fmt.Errorf("failed to create new space in db, error: %w", err)
 	}
+	_ = c.git.CommitFiles(ctx, *commitFilesReq)
 	dbRepo.Path = repoPath
 
 	err = c.createSpaceDefaultFiles(ctx, dbRepo, req, templatePath)
diff --git a/component/space_ce_test.go b/component/space_ce_test.go
@@ -44,7 +44,8 @@ func TestSpaceComponent_Create(t *testing.T) {
 			UUID:     "user-uuid",
 		},
 		Path: "ns/n",
-	}, nil)
+	}, &gitserver.CommitFilesReq{}, nil)
+	sc.mocks.gitServer.EXPECT().CommitFiles(ctx, gitserver.CommitFilesReq{}).Return(nil)
 
 	var wg sync.WaitGroup
 	wg.Add(1)

Original file line number	Diff line number	Diff line change
`@@ -93,7 +93,7 @@ func (c codeComponentImpl) Create(ctx context.Context, req types.CreateCodeReq`
`93`	`93`	`Path: types.GitattributesFileName,`
`94`	`94`	`},`
`95`	`95`	`}`
`96`		`- _, dbRepo, err := c.repoComponent.CreateRepo(ctx, req.CreateRepoReq)`
	`96`	`+ _, dbRepo, commitFilesReq, err := c.repoComponent.CreateRepo(ctx, req.CreateRepoReq)`
`97`	`97`	`if err != nil {`
`98`	`98`	`return nil, err`
`99`	`99`	`}`
`@@ -109,6 +109,8 @@ func (c codeComponentImpl) Create(ctx context.Context, req types.CreateCodeReq`
`109`	`109`	`return nil, fmt.Errorf("failed to create database code, cause: %w", err)`
`110`	`110`	`}`
`111`	`111`
	`112`	`+ _ = c.gitServer.CommitFiles(ctx, *commitFilesReq)`
	`113`	`+`
`112`	`114`	`for _, tag := range code.Repository.Tags {`
`113`	`115`	`tags = append(tags, types.RepoTag{`
`114`	`116`	`Name: tag.Name,`
Original file line number	Diff line number	Diff line change
`@@ -128,7 +128,7 @@ func (c datasetComponentImpl) Create(ctx context.Context, req types.CreateData`
`128`	`128`	`Path: types.GitattributesFileName,`
`129`	`129`	`},`
`130`	`130`	`}`
`131`		`- _, dbRepo, err := c.repoComponent.CreateRepo(ctx, req.CreateRepoReq)`
	`131`	`+ _, dbRepo, commitFilesReq, err := c.repoComponent.CreateRepo(ctx, req.CreateRepoReq)`
`132`	`132`	`if err != nil {`
`133`	`133`	`return nil, err`
`134`	`134`	`}`
`@@ -144,6 +144,8 @@ func (c datasetComponentImpl) Create(ctx context.Context, req types.CreateData`
`144`	`144`	`return nil, fmt.Errorf("failed to create database dataset, cause: %w", err)`
`145`	`145`	`}`
`146`	`146`
	`147`	`+ _ = c.gitServer.CommitFiles(ctx, *commitFilesReq)`
	`148`	`+`
`147`	`149`	`for _, tag := range dataset.Repository.Tags {`
`148`	`150`	`tags = append(tags, types.RepoTag{`
`149`	`151`	`Name: tag.Name,`
Original file line number	Diff line number	Diff line change
`@@ -103,7 +103,7 @@ func (m mcpServerComponentImpl) Create(ctx context.Context, req types.CreateMC`
`103`	`103`	`Path: types.ReadmeFileName,`
`104`	`104`	`},`
`105`	`105`	`}`
`106`		`- _, dbRepo, err := m.repoComponent.CreateRepo(ctx, req.CreateRepoReq)`
	`106`	`+ _, dbRepo, commitFilesReq, err := m.repoComponent.CreateRepo(ctx, req.CreateRepoReq)`
`107`	`107`	`if err != nil {`
`108`	`108`	`return nil, fmt.Errorf("fail to create mcp repo cause: %w", err)`
`109`	`109`	`}`
`@@ -120,6 +120,8 @@ func (m mcpServerComponentImpl) Create(ctx context.Context, req types.CreateMC`
`120`	`120`	`return nil, fmt.Errorf("fail to create mcp server cause: %w", err)`
`121`	`121`	`}`
`122`	`122`
	`123`	`+ _ = m.gitServer.CommitFiles(ctx, *commitFilesReq)`
	`124`	`+`
`123`	`125`	`for _, tag := range mcpServer.Repository.Tags {`
`124`	`126`	`tags = append(tags, types.RepoTag{`
`125`	`127`	`Name: tag.Name,`
Original file line number	Diff line number	Diff line change
`@@ -267,7 +267,7 @@ func (c modelComponentImpl) Create(ctx context.Context, req types.CreateModelR`
`267`	`267`	`Path: types.GitattributesFileName,`
`268`	`268`	`},`
`269`	`269`	`}`
`270`		`- _, dbRepo, err := c.repoComponent.CreateRepo(ctx, req.CreateRepoReq)`
	`270`	`+ _, dbRepo, commitFilesReq, err := c.repoComponent.CreateRepo(ctx, req.CreateRepoReq)`
`271`	`271`	`if err != nil {`
`272`	`272`	`return nil, err`
`273`	`273`	`}`
`@@ -287,6 +287,8 @@ func (c modelComponentImpl) Create(ctx context.Context, req types.CreateModelR`
`287`	`287`	`return nil, fmt.Errorf("failed to create database model, cause: %w", err)`
`288`	`288`	`}`
`289`	`289`
	`290`	`+ _ = c.gitServer.CommitFiles(ctx, *commitFilesReq)`
	`291`	`+`
`290`	`292`	`for _, tag := range model.Repository.Tags {`
`291`	`293`	`tags = append(tags, types.RepoTag{`
`292`	`294`	`Name: tag.Name,`