feat: add DELETE endpoint for admin endpoint

Yuan325 · Yuan325 · commit 7cf064fd644c · 2026-03-27T15:57:28.000-07:00
diff --git a/internal/server/admin.go b/internal/server/admin.go
@@ -36,10 +36,51 @@ func adminRouter(s *Server) (chi.Router, error) {
 	r.Use(render.SetContentType(render.ContentTypeJSON))
 
 	r.Put("/{kind}/{name}", func(w http.ResponseWriter, r *http.Request) { createOrUpdatePrimitives(s, w, r) })
+	r.Delete("/{kind}/{name}", func(w http.ResponseWriter, r *http.Request) { deletePrimitives(s, w, r) })
 
 	return r, nil
 }
 
+// deletePrimitives handles the deletion of primitives
+// Invalid primitive kind will result in http.StatusBadRequest
+// Primitive not found will result in http.StatusNotFound
+func deletePrimitives(s *Server, w http.ResponseWriter, r *http.Request) {
+	kind := chi.URLParam(r, "kind")
+	name := chi.URLParam(r, "name")
+	ctx := r.Context()
+	ctx = util.WithInstrumentation(ctx, s.instrumentation)
+
+	var deleted bool
+	switch strings.ToLower(kind) {
+	case "source":
+		deleted = s.ResourceMgr.DeleteSource(name)
+	case "authservice":
+		deleted = s.ResourceMgr.DeleteAuthService(name)
+	case "embeddingmodel":
+		deleted = s.ResourceMgr.DeleteEmbeddingModel(name)
+	case "tool":
+		deleted = s.ResourceMgr.DeleteTool(name)
+	case "toolset":
+		deleted = s.ResourceMgr.DeleteToolset(name)
+	case "prompt":
+		deleted = s.ResourceMgr.DeletePrompt(name)
+	default:
+		err := fmt.Errorf("invalid primitive kind provided")
+		s.logger.DebugContext(ctx, err.Error())
+		_ = render.Render(w, r, newErrResponse(err, http.StatusBadRequest))
+		return
+	}
+
+	if !deleted {
+		err := fmt.Errorf("%s %s not found", kind, name)
+		s.logger.DebugContext(ctx, err.Error())
+		_ = render.Render(w, r, newErrResponse(err, http.StatusNotFound))
+		return
+	}
+
+	w.WriteHeader(http.StatusOK)
+}
+
 // createOrUpdatePrimitives handles the creation or updating of primitives
 // changing name will result in creation of a new primitive instead of replacing
 // existing primitive
diff --git a/internal/server/admin_test.go b/internal/server/admin_test.go
@@ -68,7 +68,7 @@ func init() {
 	})
 }
 
-func TestUpdateEndpoint(t *testing.T) {
+func TestAdminUpdateEndpoint(t *testing.T) {
 	r, shutdown := setUpServer(t, "admin", map[string]sources.Source{}, map[string]auth.AuthService{}, map[string]embeddingmodels.EmbeddingModel{}, map[string]tools.Tool{}, map[string]tools.Toolset{}, map[string]prompts.Prompt{}, map[string]prompts.Promptset{})
 	defer shutdown()
 	ts := runServer(r, false)
@@ -144,3 +144,84 @@ func TestUpdateEndpoint(t *testing.T) {
 		})
 	}
 }
+
+func TestAdminDeleteEndpoint(t *testing.T) {
+	mockSources := map[string]sources.Source{"test-source": testutils.MockSource{}}
+	mockAuthServices := map[string]auth.AuthService{"test-auth-service": testutils.MockAuthService{}}
+	mockEmbeddingModel := map[string]embeddingmodels.EmbeddingModel{"test-embedding-model": testutils.MockEmbeddingModel{}}
+	mockTool := map[string]tools.Tool{"test-tool": testutils.MockTool{}}
+	mockToolset := map[string]tools.Toolset{"test-toolset": tools.Toolset{}}
+	mockPrompt := map[string]prompts.Prompt{"test-prompt": testutils.MockPrompt{}}
+	r, shutdown := setUpServer(t, "admin", mockSources, mockAuthServices, mockEmbeddingModel, mockTool, mockToolset, mockPrompt, map[string]prompts.Promptset{})
+	defer shutdown()
+	ts := runServer(r, false)
+	defer ts.Close()
+
+	tests := []struct {
+		name               string
+		kind               string
+		resourceName       string
+		expectedStatusCode int
+	}{
+		{
+			name:               "Delete Source - Success",
+			kind:               "source",
+			resourceName:       "test-source",
+			expectedStatusCode: http.StatusOK,
+		},
+		{
+			name:               "Delete Auth Service - Success",
+			kind:               "authService",
+			resourceName:       "test-auth-service",
+			expectedStatusCode: http.StatusOK,
+		},
+		{
+			name:               "Delete Embedding Model - Success",
+			kind:               "embeddingModel",
+			resourceName:       "test-embedding-model",
+			expectedStatusCode: http.StatusOK,
+		},
+		{
+			name:               "Delete Tool - Success",
+			kind:               "tool",
+			resourceName:       "test-tool",
+			expectedStatusCode: http.StatusOK,
+		},
+		{
+			name:               "Delete Toolset - Success",
+			kind:               "toolset",
+			resourceName:       "test-toolset",
+			expectedStatusCode: http.StatusOK,
+		},
+		{
+			name:               "Delete Prompt - Success",
+			kind:               "prompt",
+			resourceName:       "test-prompt",
+			expectedStatusCode: http.StatusOK,
+		},
+		{
+			name:               "Delete Non-existent Primitive - Not Found",
+			kind:               "source",
+			resourceName:       "non-existent-source",
+			expectedStatusCode: http.StatusNotFound,
+		},
+		{
+			name:               "Delete with Invalid Kind - Bad Request",
+			kind:               "invalidKind",
+			resourceName:       "some-name",
+			expectedStatusCode: http.StatusBadRequest,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			resp, body, err := runRequest(ts, http.MethodDelete, fmt.Sprintf("/%s/%s", tt.kind, tt.resourceName), nil, nil)
+			if err != nil {
+				t.Fatalf("unexpected error during request: %s", err)
+			}
+			if resp.StatusCode != tt.expectedStatusCode {
+				t.Fatalf("response status code is not %d, got %d, %s", tt.expectedStatusCode, resp.StatusCode, string(body))
+			}
+		})
+	}
+}
diff --git a/internal/server/resources/resources.go b/internal/server/resources/resources.go
@@ -260,6 +260,7 @@ func (r *ResourceManager) UpdateEmbeddingModel(ctx context.Context, name string,
 	return nil
 }
 
+// removeFirstFromToolset removes a target tool from toolset
 func removeFirstFromToolset(ts tools.Toolset, target string) tools.Toolset {
 	for i, tool := range ts.Tools {
 		if tool != nil && (*tool) != nil && (*tool).McpManifest().Name == target {
@@ -375,3 +376,82 @@ func (r *ResourceManager) UpdatePrompt(ctx context.Context, name string, config
 	r.prompts[name] = p
 	return nil
 }
+
+// DeleteSource deletes a source.
+func (r *ResourceManager) DeleteSource(name string) bool {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	_, ok := r.sources[name]
+	if !ok {
+		return false
+	}
+	delete(r.sources, name)
+	return true
+}
+
+// DeleteAuthService deletes an auth service.
+func (r *ResourceManager) DeleteAuthService(name string) bool {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	_, ok := r.authServices[name]
+	if !ok {
+		return false
+	}
+	delete(r.authServices, name)
+	return true
+}
+
+// DeleteEmbeddingModel deletes an embedding model.
+func (r *ResourceManager) DeleteEmbeddingModel(name string) bool {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	_, ok := r.embeddingModels[name]
+	if !ok {
+		return false
+	}
+	delete(r.embeddingModels, name)
+	return true
+}
+
+// DeleteTool deletes a tool.
+func (r *ResourceManager) DeleteTool(name string) bool {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	_, ok := r.tools[name]
+	if !ok {
+		return false
+	}
+	delete(r.tools, name)
+
+	// Also remove the tool from the default toolset
+	// This function do not remove tool from other toolset. User have to update
+	// toolset explicitly
+	if defaultToolset, toolsetExists := r.toolsets[""]; toolsetExists {
+		r.toolsets[""] = removeFirstFromToolset(defaultToolset, name)
+	}
+	return true
+}
+
+// DeleteToolset deletes a toolset.
+func (r *ResourceManager) DeleteToolset(name string) bool {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	_, ok := r.toolsets[name]
+	if !ok {
+		return false
+	}
+	delete(r.toolsets, name)
+	return true
+}
+
+// DeletePrompt deletes a prompt.
+func (r *ResourceManager) DeletePrompt(name string) bool {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	_, ok := r.prompts[name]
+	if !ok {
+		return false
+	}
+	delete(r.prompts, name)
+	return true
+}
diff --git a/internal/server/resources/resources_test.go b/internal/server/resources/resources_test.go
@@ -255,3 +255,94 @@ func TestCreateAndUpdatePrimitives(t *testing.T) {
 		t.Fatalf("update failed: got %+v, want %+v", pc, pConfig)
 	}
 }
+
+func TestDeletePrimitives(t *testing.T) {
+	resMgr := resources.NewResourceManager(
+		map[string]sources.Source{"foo": testutils.MockSource{}},
+		map[string]auth.AuthService{"foo": testutils.MockAuthService{}},
+		map[string]embeddingmodels.EmbeddingModel{"foo": testutils.MockEmbeddingModel{}},
+		map[string]tools.Tool{"foo": testutils.MockTool{}},
+		map[string]tools.Toolset{"foo": tools.Toolset{}},
+		map[string]prompts.Prompt{"foo": testutils.MockPrompt{}},
+		map[string]prompts.Promptset{},
+	)
+
+	var deleted, found bool
+	deleted = resMgr.DeleteSource("foo")
+	if !deleted {
+		t.Fatalf("expected delete to be successful")
+	}
+	_, found = resMgr.GetSource("foo")
+	if found {
+		t.Fatalf("found source but expected to be deleted")
+	}
+	deleted = resMgr.DeleteSource("nonexistent")
+	if deleted {
+		t.Fatalf("expected delete to be successful")
+	}
+
+	deleted = resMgr.DeleteAuthService("foo")
+	if !deleted {
+		t.Fatalf("expected delete to be successful")
+	}
+	_, found = resMgr.GetAuthService("foo")
+	if found {
+		t.Fatalf("found auth service but expected to be deleted")
+	}
+	deleted = resMgr.DeleteAuthService("nonexistent")
+	if deleted {
+		t.Fatalf("expected delete to be successful")
+	}
+
+	deleted = resMgr.DeleteEmbeddingModel("foo")
+	if !deleted {
+		t.Fatalf("expected delete to be successful")
+	}
+	_, found = resMgr.GetEmbeddingModel("foo")
+	if found {
+		t.Fatalf("found embedding model but expected to be deleted")
+	}
+	deleted = resMgr.DeleteEmbeddingModel("nonexistent")
+	if deleted {
+		t.Fatalf("expected delete to be successful")
+	}
+
+	deleted = resMgr.DeleteTool("foo")
+	if !deleted {
+		t.Fatalf("expected delete to be successful")
+	}
+	_, found = resMgr.GetTool("foo")
+	if found {
+		t.Fatalf("found tool but expected to be deleted")
+	}
+	deleted = resMgr.DeleteTool("nonexistent")
+	if deleted {
+		t.Fatalf("expected delete to be successful")
+	}
+
+	deleted = resMgr.DeleteToolset("foo")
+	if !deleted {
+		t.Fatalf("expected delete to be successful")
+	}
+	_, found = resMgr.GetToolset("foo")
+	if found {
+		t.Fatalf("found toolset but expected to be deleted")
+	}
+	deleted = resMgr.DeleteToolset("nonexistent")
+	if deleted {
+		t.Fatalf("expected delete to be successful")
+	}
+
+	deleted = resMgr.DeletePrompt("foo")
+	if !deleted {
+		t.Fatalf("expected delete to be successful")
+	}
+	_, found = resMgr.GetPrompt("foo")
+	if found {
+		t.Fatalf("found prompt but expected to be deleted")
+	}
+	deleted = resMgr.DeletePrompt("nonexistent")
+	if deleted {
+		t.Fatalf("expected delete to be successful")
+	}
+}
