Deduplicate server JSON structs between publisher and registry (#318)

<!-- Provide a brief summary of your changes -->

## Motivation and Context
<!-- Why is this change needed? What problem does it solve? -->

The following PR eliminates duplicate struct definitions by migrating
the publisher tool to use canonical types from pkg/model, creating a
single source of truth across the codebase. The publisher tool
previously had its own copies of structs that were duplicated, ie.
ServerJSON, Package, Repository, VersionDetail, EnvironmentVariable,
RuntimeArgument and a few others which was not optimal


**Changes in the PR:**
- Refactored the structs to single canonical types located at pkg/model
- Refactor the implementation to use/build canonical structures directly
  - Remove all duplicate definitions (5 structs eliminated)
- Publisher now uses model.ServerJSON, model.Package, model.Repository,
etc.
- Renamed some of the structs to better reflect their use case, i.e.
ServerJSON instead of ServerDetail
- Fixes an issue where the Remote property was missing from the previous
publisher copy of the Server

**Benefits:**
  - Single source of truth - Schema changes in one place
  - Type safety - Compiler catches mismatches
  - Enhanced validation - Field constraints and bson tags
  - Zero breaking changes - Same CLI interface and JSON output
  - Future-proof - New canonical fields automatically available

Supersedes: #217 and #240

## How Has This Been Tested?
<!-- Have you tested this in a real application? Which scenarios were
tested? -->

Locally

## Breaking Changes
<!-- Will users need to update their code or configurations? -->
No

## Types of changes
<!-- What types of changes does your code introduce? Put an `x` in all
the boxes that apply: -->
- [x] Bug fix (non-breaking change which fixes an issue)
- [ ] New feature (non-breaking change which adds functionality)
- [ ] Breaking change (fix or feature that would cause existing
functionality to change)
- [ ] Documentation update

## Checklist
<!-- Go over all the following points, and put an `x` in all the boxes
that apply. -->
- [ ] I have read the [MCP
Documentation](https://modelcontextprotocol.io)
- [ ] My code follows the repository's style guidelines
- [ ] New and existing tests pass locally
- [ ] I have added appropriate error handling
- [ ] I have added or updated documentation as needed

## Additional context
<!-- Add any other context, implementation notes, or design decisions
-->

---------

Signed-off-by: Radoslav Dimitrov <radoslav@stacklok.com>
This commit is contained in:
Radoslav Dimitrov 2025-08-28 16:58:15 +03:00 • committed by GitHub
commit 099a2d702e
No known key found for this signature in database
GPG key ID: B5690EEEBB952194

View file

@ -17,7 +17,8 @@ import (
v0 "github.com/modelcontextprotocol/registry/internal/api/handlers/v0"
"github.com/modelcontextprotocol/registry/internal/auth"
"github.com/modelcontextprotocol/registry/internal/config"
"github.com/modelcontextprotocol/registry/internal/model"
apiv1 "github.com/modelcontextprotocol/registry/pkg/api/v1"
"github.com/modelcontextprotocol/registry/pkg/model"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/mock"
"github.com/stretchr/testify/require"
@ -28,33 +29,33 @@ type MockRegistryService struct {
mock.Mock
}
func (m *MockRegistryService) List(cursor string, limit int) ([]model.ServerResponse, string, error) {
func (m *MockRegistryService) List(cursor string, limit int) ([]apiv1.ServerRecord, string, error) {
args := m.Called(cursor, limit)
return args.Get(0).([]model.ServerResponse), args.String(1), args.Error(2)
return args.Get(0).([]apiv1.ServerRecord), args.String(1), args.Error(2)
}
func (m *MockRegistryService) GetByID(id string) (*model.ServerResponse, error) {
func (m *MockRegistryService) GetByID(id string) (*apiv1.ServerRecord, error) {
args := m.Called(id)
if args.Get(0) == nil {
return nil, args.Error(1)
}
return args.Get(0).(*model.ServerResponse), args.Error(1)
return args.Get(0).(*apiv1.ServerRecord), args.Error(1)
}
func (m *MockRegistryService) Publish(request model.PublishRequest) (*model.ServerResponse, error) {
func (m *MockRegistryService) Publish(request apiv1.PublishRequest) (*apiv1.ServerRecord, error) {
args := m.Called(request)
if args.Get(0) == nil {
return nil, args.Error(1)
}
return args.Get(0).(*model.ServerResponse), args.Error(1)
return args.Get(0).(*apiv1.ServerRecord), args.Error(1)
}
func (m *MockRegistryService) EditServer(id string, request model.PublishRequest) (*model.ServerResponse, error) {
func (m *MockRegistryService) EditServer(id string, request apiv1.PublishRequest) (*apiv1.ServerRecord, error) {
args := m.Called(id, request)
if args.Get(0) == nil {
return nil, args.Error(1)
}
return args.Get(0).(*model.ServerResponse), args.Error(1)
return args.Get(0).(*apiv1.ServerRecord), args.Error(1)
}
// Helper function to generate a valid JWT token for testing
@ -87,8 +88,8 @@ func TestPublishEndpoint(t *testing.T) {
}{
{
name: "successful publish with GitHub auth",
requestBody: model.PublishRequest{
Server: model.ServerDetail{
requestBody: apiv1.PublishRequest{
Server: model.ServerJSON{
Name: "io.github.example/test-server",
Description: "A test server",
Repository: model.Repository{
@ -102,21 +103,21 @@ func TestPublishEndpoint(t *testing.T) {
},
},
tokenClaims: &auth.JWTClaims{
AuthMethod: model.AuthMethodGitHubAT,
AuthMethod: auth.MethodGitHubAT,
AuthMethodSubject: "example",
Permissions: []auth.Permission{
{Action: auth.PermissionActionPublish, ResourcePattern: "io.github.example/*"},
},
},
setupMocks: func(registry *MockRegistryService) {
registry.On("Publish", mock.AnythingOfType("model.PublishRequest")).Return(&model.ServerResponse{}, nil)
registry.On("Publish", mock.AnythingOfType("v1.PublishRequest")).Return(&apiv1.ServerRecord{}, nil)
},
expectedStatus: http.StatusOK,
},
{
name: "successful publish with no auth (AuthMethodNone)",
requestBody: model.PublishRequest{
Server: model.ServerDetail{
requestBody: apiv1.PublishRequest{
Server: model.ServerJSON{
Name: "example/test-server",
Description: "A test server without auth",
Repository: model.Repository{
@ -130,19 +131,19 @@ func TestPublishEndpoint(t *testing.T) {
},
},
tokenClaims: &auth.JWTClaims{
AuthMethod: model.AuthMethodNone,
AuthMethod: auth.MethodNone,
Permissions: []auth.Permission{
{Action: auth.PermissionActionPublish, ResourcePattern: "example/*"},
},
},
setupMocks: func(registry *MockRegistryService) {
registry.On("Publish", mock.AnythingOfType("model.PublishRequest")).Return(&model.ServerResponse{}, nil)
registry.On("Publish", mock.AnythingOfType("v1.PublishRequest")).Return(&apiv1.ServerRecord{}, nil)
},
expectedStatus: http.StatusOK,
},
{
name: "missing authorization header",
requestBody: model.PublishRequest{},
requestBody: apiv1.PublishRequest{},
authHeader: "", // Empty auth header
setupMocks: func(_ *MockRegistryService) {},
expectedStatus: http.StatusUnprocessableEntity,
@ -150,7 +151,7 @@ func TestPublishEndpoint(t *testing.T) {
},
{
name: "invalid authorization header format",
requestBody: model.PublishRequest{},
requestBody: apiv1.PublishRequest{},
authHeader: "InvalidFormat",
setupMocks: func(_ *MockRegistryService) {},
expectedStatus: http.StatusUnauthorized,
@ -158,8 +159,8 @@ func TestPublishEndpoint(t *testing.T) {
},
{
name: "invalid token",
requestBody: model.PublishRequest{
Server: model.ServerDetail{
requestBody: apiv1.PublishRequest{
Server: model.ServerJSON{
Name: "test-server",
Description: "A test server",
VersionDetail: model.VersionDetail{
@ -174,8 +175,8 @@ func TestPublishEndpoint(t *testing.T) {
},
{
name: "permission denied",
requestBody: model.PublishRequest{
Server: model.ServerDetail{
requestBody: apiv1.PublishRequest{
Server: model.ServerJSON{
Name: "io.github.other/test-server",
Description: "A test server",
VersionDetail: model.VersionDetail{
@ -189,7 +190,7 @@ func TestPublishEndpoint(t *testing.T) {
},
},
tokenClaims: &auth.JWTClaims{
AuthMethod: model.AuthMethodGitHubAT,
AuthMethod: auth.MethodGitHubAT,
Permissions: []auth.Permission{
{Action: auth.PermissionActionPublish, ResourcePattern: "io.github.example/*"},
},
@ -200,8 +201,8 @@ func TestPublishEndpoint(t *testing.T) {
},
{
name: "registry service error",
requestBody: model.PublishRequest{
Server: model.ServerDetail{
requestBody: apiv1.PublishRequest{
Server: model.ServerJSON{
Name: "example/test-server",
Description: "A test server",
VersionDetail: model.VersionDetail{
@ -215,13 +216,13 @@ func TestPublishEndpoint(t *testing.T) {
},
},
tokenClaims: &auth.JWTClaims{
AuthMethod: model.AuthMethodNone,
AuthMethod: auth.MethodNone,
Permissions: []auth.Permission{
{Action: auth.PermissionActionPublish, ResourcePattern: "*"},
},
},
setupMocks: func(registry *MockRegistryService) {
registry.On("Publish", mock.AnythingOfType("model.PublishRequest")).Return(nil, errors.New("cannot publish duplicate version"))
registry.On("Publish", mock.AnythingOfType("v1.PublishRequest")).Return(nil, errors.New("cannot publish duplicate version"))
},
expectedStatus: http.StatusBadRequest,
expectedError: "Failed to publish server",