feat(api): add namespace conflicts detection system

- Add NamespaceConflicts model and detection method
- Replace NamespaceResolve usage with NamespaceConflicts in
  CreateNamespace
- Implement NamespaceConflicts store method with MongoDB aggregation
- Add comprehensive test coverage for conflict detection
- Simplify namespace creation validation logic

Author: heiytor

api/services/namespace.go

@@ -44,7 +44,8 @@ func (s *service) CreateNamespace(ctx context.Context, req *requests.NamespaceCr
 		}
 	}
 
-	if dup, err := s.store.NamespaceResolve(ctx, store.NamespaceNameResolver, strings.ToLower(req.Name)); dup != nil || (err != nil && err != store.ErrNoDocuments) {
+	conflictsTarget := &models.NamespaceConflicts{Name: strings.ToLower(req.Name)}
+	if _, has, err := s.store.NamespaceConflicts(ctx, conflictsTarget); has || err != nil {
 		return nil, NewErrNamespaceDuplicated(err)
 	}
 

api/services/namespace_test.go

@@ -444,50 +444,15 @@ func TestCreateNamespace(t *testing.T) {
 					}, nil).
 					Once()
 				storeMock.
-					On("NamespaceResolve", ctx, store.NamespaceNameResolver, "namespace").
-					Return(&models.Namespace{Name: "namespace"}, nil).
+					On("NamespaceConflicts", ctx, &models.NamespaceConflicts{Name: "namespace"}).
+					Return(nil, true, nil).
 					Once()
 			},
 			expected: Expected{
 				ns:  nil,
 				err: NewErrNamespaceDuplicated(nil),
 			},
 		},
-		{
-			description: "fails retrieve namespace fails without ErrNoDocuments",
-			req: &requests.NamespaceCreate{
-				UserID:   "000000000000000000000000",
-				Name:     "namespace",
-				TenantID: "00000000-0000-4000-0000-000000000000",
-			},
-			requiredMocks: func() {
-				storeMock.
-					On("UserGetInfo", ctx, "000000000000000000000000").
-					Return(
-						&models.UserInfo{
-							OwnedNamespaces:      []models.Namespace{{}},
-							AssociatedNamespaces: []models.Namespace{},
-						},
-						nil,
-					).
-					Once()
-				storeMock.
-					On("UserResolve", ctx, store.UserIDResolver, "000000000000000000000000").
-					Return(&models.User{
-						ID:            "000000000000000000000000",
-						MaxNamespaces: 3,
-					}, nil).
-					Once()
-				storeMock.
-					On("NamespaceResolve", ctx, store.NamespaceNameResolver, "namespace").
-					Return(nil, errors.New("error")).
-					Once()
-			},
-			expected: Expected{
-				ns:  nil,
-				err: NewErrNamespaceDuplicated(errors.New("error")),
-			},
-		},
 		{
 			description: "fails when store namespace create fails",
 			req: &requests.NamespaceCreate{
@@ -514,8 +479,8 @@ func TestCreateNamespace(t *testing.T) {
 					}, nil).
 					Once()
 				storeMock.
-					On("NamespaceResolve", ctx, store.NamespaceNameResolver, "namespace").
-					Return(nil, store.ErrNoDocuments).
+					On("NamespaceConflicts", ctx, &models.NamespaceConflicts{Name: "namespace"}).
+					Return(nil, false, nil).
 					Once()
 				// envs.IsCommunity = true
 				envMock.
@@ -591,8 +556,8 @@ func TestCreateNamespace(t *testing.T) {
 					}, nil).
 					Once()
 				storeMock.
-					On("NamespaceResolve", ctx, store.NamespaceNameResolver, "namespace").
-					Return(nil, store.ErrNoDocuments).
+					On("NamespaceConflicts", ctx, &models.NamespaceConflicts{Name: "namespace"}).
+					Return(nil, false, nil).
 					Once()
 				// envs.IsCommunity = true
 				envMock.
@@ -707,8 +672,8 @@ func TestCreateNamespace(t *testing.T) {
 					}, nil).
 					Once()
 				storeMock.
-					On("NamespaceResolve", ctx, store.NamespaceNameResolver, "namespace").
-					Return(nil, store.ErrNoDocuments).
+					On("NamespaceConflicts", ctx, &models.NamespaceConflicts{Name: "namespace"}).
+					Return(nil, false, nil).
 					Once()
 				// envs.IsCommunity = true
 				envMock.
@@ -829,8 +794,8 @@ func TestCreateNamespace(t *testing.T) {
 					}, nil).
 					Once()
 				storeMock.
-					On("NamespaceResolve", ctx, store.NamespaceNameResolver, "namespace").
-					Return(nil, store.ErrNoDocuments).
+					On("NamespaceConflicts", ctx, &models.NamespaceConflicts{Name: "namespace"}).
+					Return(nil, false, nil).
 					Once()
 				envMock.
 					On("Get", "SHELLHUB_CLOUD").
@@ -946,8 +911,8 @@ func TestCreateNamespace(t *testing.T) {
 					}, nil).
 					Once()
 				storeMock.
-					On("NamespaceResolve", ctx, store.NamespaceNameResolver, "namespace").
-					Return(nil, store.ErrNoDocuments).
+					On("NamespaceConflicts", ctx, &models.NamespaceConflicts{Name: "namespace"}).
+					Return(nil, false, nil).
 					Once()
 				envMock.
 					On("Get", "SHELLHUB_CLOUD").

api/store/mocks/store.go

@@ -289,6 +289,38 @@ func (s *Store) NamespaceCreate(ctx context.Context, namespace *models.Namespace
 	return namespace, err
 }
 
+func (s *Store) NamespaceConflicts(ctx context.Context, target *models.NamespaceConflicts) ([]string, bool, error) {
+	pipeline := []bson.M{
+		{
+			"$match": bson.M{
+				"$or": []bson.M{
+					{"name": target.Name},
+				},
+			},
+		},
+	}
+
+	cursor, err := s.db.Collection("namespaces").Aggregate(ctx, pipeline)
+	if err != nil {
+		return nil, false, FromMongoError(err)
+	}
+	defer cursor.Close(ctx)
+
+	namespace := new(models.NamespaceConflicts)
+	conflicts := make([]string, 0)
+	for cursor.Next(ctx) {
+		if err := cursor.Decode(&namespace); err != nil {
+			return nil, false, FromMongoError(err)
+		}
+
+		if namespace.Name == target.Name {
+			conflicts = append(conflicts, "name")
+		}
+	}
+
+	return conflicts, len(conflicts) > 0, nil
+}
+
 func (s *Store) NamespaceDelete(ctx context.Context, tenantID string) error {
 	session, err := s.db.Client().StartSession()
 	if err != nil {

api/store/mongo/namespace.go

@@ -428,6 +428,52 @@ func TestNamespaceCreate(t *testing.T) {
 	}
 }
 
+func TestNamespaceConflicts(t *testing.T) {
+	type Expected struct {
+		conflicts []string
+		ok        bool
+		err       error
+	}
+
+	cases := []struct {
+		description string
+		target      *models.NamespaceConflicts
+		fixtures    []string
+		expected    Expected
+	}{
+		{
+			description: "no conflicts when target is empty",
+			target:      &models.NamespaceConflicts{},
+			fixtures:    []string{fixtureNamespaces},
+			expected:    Expected{[]string{}, false, nil},
+		},
+		{
+			description: "no conflicts with non existing name",
+			target:      &models.NamespaceConflicts{Name: "nonexistent-namespace"},
+			fixtures:    []string{fixtureNamespaces},
+			expected:    Expected{[]string{}, false, nil},
+		},
+		{
+			description: "conflict detected with existing name",
+			target:      &models.NamespaceConflicts{Name: "namespace-1"},
+			fixtures:    []string{fixtureNamespaces},
+			expected:    Expected{[]string{"name"}, true, nil},
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.description, func(t *testing.T) {
+			ctx := context.Background()
+
+			require.NoError(t, srv.Apply(tc.fixtures...))
+			t.Cleanup(func() { require.NoError(t, srv.Reset()) })
+
+			conflicts, ok, err := s.NamespaceConflicts(ctx, tc.target)
+			require.Equal(t, tc.expected, Expected{conflicts, ok, err})
+		})
+	}
+}
+
 func TestNamespaceEdit(t *testing.T) {
 	cases := []struct {
 		description string

api/store/mongo/namespace_test.go

@@ -38,6 +38,8 @@ type NamespaceStore interface {
 
 	NamespaceCreate(ctx context.Context, namespace *models.Namespace) (*models.Namespace, error)
 
+	NamespaceConflicts(ctx context.Context, target *models.NamespaceConflicts) (conflicts []string, has bool, err error)
+
 	// NamespaceEdit updates a namespace with the specified tenant.
 	// It returns an error, if any, or store.ErrNoDocuments if the namespace does not exist.
 	NamespaceEdit(ctx context.Context, tenant string, changes *models.NamespaceChanges) error

api/store/namespace.go

@@ -86,3 +86,16 @@ const DefaultAnnouncementMessage = `
 *                                                                *
 ******************************************************************
 `
+
+// NamespaceConflicts holds namespace attributes that must be unique for each document and can be utilized in queries
+// to identify conflicts.
+type NamespaceConflicts struct {
+	Name string
+}
+
+// Distinct removes the c attributes whether it's equal to the namespace attribute.
+func (c *NamespaceConflicts) Distinct(namespace *Namespace) {
+	if c.Name == namespace.Name {
+		c.Name = ""
+	}
+}