Allow for vendor extensions on servers (#298)
<!-- Provide a brief summary of your changes -->
This PR serves as a placeholder and brings together all of the changes
related to supporting vendor extensions passed through the API. The idea
is to have a single place to track and review the work as it comes
together (even if it’s still a bit of a work in progress).
**The changes in this PR cover:**
* Updates on the data model
* Updates on both databases (in-memory and postgresql), added a new
table to PSQL for tracking the extensions leaving the server table only
for the clean server.json properties
* Updates the seed.json file (thus the big line change)
* Adds a seed-migrate tool to help migrating an existing seed file to
the new format
* Updates the seed import mechanism to support this
* Updates the existing tests - unit, integration and validation tests
* Adds the publish handler to the OpenAPI spec (it was missing)
* Fixes linting errors
* Updates on the API side on (publish, list, get) to support the new
format of `ServerResponse` -
```
{
"server": {},
"x-io.modelcontextprotocol.registry": {}, /*not available for publish since this gets populated by the registry*/
"x-publisher": {}
}
```
## Motivation and Context
<!-- Why is this change needed? What problem does it solve? -->
Motivated by the discussions in:
https://github.com/modelcontextprotocol/registry/discussions/284
## How Has This Been Tested?
<!-- Have you tested this in a real application? Which scenarios were
tested? -->
Locally and by running all of the tests
## Breaking Changes
<!-- Will users need to update their code or configurations? -->
Yes, it changes both the API and the format of the seed file
## Types of changes
<!-- What types of changes does your code introduce? Put an `x` in all
the boxes that apply: -->
- [ ] Bug fix (non-breaking change which fixes an issue)
- [ ] New feature (non-breaking change which adds functionality)
- [x] Breaking change (fix or feature that would cause existing
functionality to change)
- [ ] Documentation update
---
Signed-off-by: Radoslav Dimitrov <radoslav@stacklok.com>
Co-authored-by: adam jones <domdomegg+git@gmail.com>
This commit is contained in:
Radoslav Dimitrov
GitHub
parent
ebaf4c9c99
commit
8d7e471fd3
6 changed files with 19980 additions and 15589 deletions
|
|
@ -16,14 +16,14 @@ var (
|
|||
ErrInvalidVersion = errors.New("invalid version: cannot publish older version after newer version")
|
||||
)
|
||||
|
||||
// Database defines the interface for database operations on MCPRegistry entries
|
||||
// Database defines the interface for database operations with extension wrapper architecture
|
||||
type Database interface {
|
||||
// List retrieves all MCPRegistry entries with optional filtering
|
||||
List(ctx context.Context, filter map[string]any, cursor string, limit int) ([]*model.Server, string, error)
|
||||
// GetByID retrieves a single ServerDetail by it's ID
|
||||
GetByID(ctx context.Context, id string) (*model.ServerDetail, error)
|
||||
// Publish adds a new ServerDetail to the database
|
||||
Publish(ctx context.Context, serverDetail *model.ServerDetail) error
|
||||
// List retrieves all ServerRecord entries with optional filtering
|
||||
List(ctx context.Context, filter map[string]any, cursor string, limit int) ([]*model.ServerRecord, string, error)
|
||||
// GetByID retrieves a single ServerRecord by its ID
|
||||
GetByID(ctx context.Context, id string) (*model.ServerRecord, error)
|
||||
// Publish adds a new server to the database with separated server.json and extensions
|
||||
Publish(ctx context.Context, serverDetail model.ServerDetail, publisherExtensions map[string]interface{}) (*model.ServerRecord, error)
|
||||
// ImportSeed imports initial data from a seed file
|
||||
ImportSeed(ctx context.Context, seedFilePath string) error
|
||||
// Close closes the database connection
|
||||
|
|
|
|||
|
|
@ -5,11 +5,8 @@ import (
|
|||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
"log"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
|
|
@ -17,255 +14,165 @@ import (
|
|||
)
|
||||
|
||||
// ReadSeedFile reads seed data from various sources:
|
||||
// 1. Local file paths (*.json files)
|
||||
// 2. Direct HTTP URLs to seed.json files
|
||||
// 1. Local file paths (*.json files) - expects extension wrapper format
|
||||
// 2. Direct HTTP URLs to seed.json files - expects extension wrapper format
|
||||
// 3. Registry root URLs (automatically appends /v0/servers and paginates)
|
||||
func ReadSeedFile(ctx context.Context, path string) ([]model.ServerDetail, error) {
|
||||
log.Printf("Reading seed data from %s", path)
|
||||
// Only the extension wrapper format is supported (array of ServerResponse objects)
|
||||
func ReadSeedFile(ctx context.Context, path string) ([]*model.ServerRecord, error) {
|
||||
var data []byte
|
||||
var err error
|
||||
|
||||
// Set default seed file path if not provided
|
||||
if path == "" {
|
||||
// Try to find the seed.json in the data directory
|
||||
path = filepath.Join("data", "seed.json")
|
||||
if _, err := os.Stat(path); os.IsNotExist(err) {
|
||||
return nil, fmt.Errorf("seed file not found at %s", path)
|
||||
}
|
||||
}
|
||||
|
||||
// Check if path is an HTTP URL
|
||||
if strings.HasPrefix(path, "http://") || strings.HasPrefix(path, "https://") {
|
||||
// Determine if this is a direct seed file URL or a registry root URL
|
||||
if strings.HasSuffix(path, ".json") || strings.Contains(path, "seed.json") {
|
||||
// Direct seed file URL - read directly
|
||||
fileContent, err := readFromHTTP(ctx, path)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to read from HTTP URL: %w", err)
|
||||
}
|
||||
return parseSeedJSON(fileContent)
|
||||
// Handle HTTP URLs
|
||||
if strings.HasSuffix(path, "/v0/servers") || strings.Contains(path, "/v0/servers") {
|
||||
// This is a registry API endpoint - fetch paginated data
|
||||
return fetchFromRegistryAPI(ctx, path)
|
||||
}
|
||||
// Registry root URL - paginate through /v0/servers endpoint
|
||||
return readFromRegistryWithContext(ctx, path)
|
||||
// This is a direct file URL
|
||||
data, err = fetchFromHTTP(ctx, path)
|
||||
} else {
|
||||
// Handle local file paths
|
||||
data, err = os.ReadFile(path)
|
||||
}
|
||||
// Read from local file
|
||||
fileContent, err := os.ReadFile(path)
|
||||
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to read file: %w", err)
|
||||
return nil, fmt.Errorf("failed to read seed data from %s: %w", path, err)
|
||||
}
|
||||
return parseSeedJSON(fileContent)
|
||||
|
||||
// Parse extension wrapper format (only supported format)
|
||||
var serverResponses []model.ServerResponse
|
||||
if err := json.Unmarshal(data, &serverResponses); err != nil {
|
||||
return nil, fmt.Errorf("failed to parse seed data as extension wrapper format: %w", err)
|
||||
}
|
||||
|
||||
if len(serverResponses) == 0 {
|
||||
return []*model.ServerRecord{}, nil
|
||||
}
|
||||
|
||||
// Convert ServerResponse to ServerRecord
|
||||
var records []*model.ServerRecord
|
||||
for _, response := range serverResponses {
|
||||
record := convertServerResponseToRecord(response)
|
||||
records = append(records, record)
|
||||
}
|
||||
|
||||
return records, nil
|
||||
}
|
||||
|
||||
// readFromHTTP reads content from an HTTP URL with timeout
|
||||
func readFromHTTP(ctx context.Context, url string) ([]byte, error) {
|
||||
client := &http.Client{
|
||||
Timeout: 30 * time.Second,
|
||||
}
|
||||
|
||||
func fetchFromHTTP(ctx context.Context, url string) ([]byte, error) {
|
||||
req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to create request: %w", err)
|
||||
return nil, fmt.Errorf("failed to create HTTP request: %w", err)
|
||||
}
|
||||
|
||||
resp, err := client.Do(req)
|
||||
resp, err := http.DefaultClient.Do(req)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to fetch URL: %w", err)
|
||||
return nil, fmt.Errorf("failed to fetch from HTTP: %w", err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
return nil, fmt.Errorf("HTTP request failed with status %d: %s", resp.StatusCode, resp.Status)
|
||||
return nil, fmt.Errorf("HTTP request failed with status: %d", resp.StatusCode)
|
||||
}
|
||||
|
||||
// Read the response body
|
||||
body, err := io.ReadAll(resp.Body)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to read response body: %w", err)
|
||||
}
|
||||
|
||||
return body, nil
|
||||
return io.ReadAll(resp.Body)
|
||||
}
|
||||
|
||||
// parseSeedJSON parses JSON content into ServerDetail objects
|
||||
func parseSeedJSON(fileContent []byte) ([]model.ServerDetail, error) {
|
||||
var servers []model.ServerDetail
|
||||
if err := json.Unmarshal(fileContent, &servers); err != nil {
|
||||
// Try parsing as a raw JSON array and then convert to our model
|
||||
var rawData []map[string]any
|
||||
if jsonErr := json.Unmarshal(fileContent, &rawData); jsonErr != nil {
|
||||
return nil, fmt.Errorf("failed to parse JSON: %w (original error: %w)", jsonErr, err)
|
||||
}
|
||||
}
|
||||
|
||||
log.Printf("Found %d server entries in seed data", len(servers))
|
||||
return servers, nil
|
||||
}
|
||||
|
||||
// PaginatedResponse represents the paginated response from /v0/servers endpoint
|
||||
// PaginatedResponse represents the structure of a paginated response from /v0/servers endpoint
|
||||
type PaginatedResponse struct {
|
||||
Data []model.Server `json:"servers"`
|
||||
Metadata Metadata `json:"metadata,omitempty"`
|
||||
}
|
||||
|
||||
// Metadata contains pagination metadata
|
||||
type Metadata struct {
|
||||
NextCursor string `json:"next_cursor,omitempty"`
|
||||
Count int `json:"count,omitempty"`
|
||||
Total int `json:"total,omitempty"`
|
||||
}
|
||||
|
||||
// readFromRegistryWithContext reads all servers from a registry by paginating through /v0/servers endpoint
|
||||
func readFromRegistryWithContext(ctx context.Context, registryURL string) ([]model.ServerDetail, error) {
|
||||
log.Printf("Reading from registry: %s", registryURL)
|
||||
|
||||
// Ensure the URL doesn't have a trailing slash
|
||||
registryURL = strings.TrimSuffix(registryURL, "/")
|
||||
|
||||
var allServers []model.ServerDetail
|
||||
func fetchFromRegistryAPI(ctx context.Context, baseURL string) ([]*model.ServerRecord, error) {
|
||||
var allRecords []*model.ServerRecord
|
||||
cursor := ""
|
||||
pageCount := 0
|
||||
|
||||
client := &http.Client{
|
||||
Timeout: 30 * time.Second,
|
||||
}
|
||||
|
||||
for {
|
||||
pageCount++
|
||||
|
||||
// Add delay between requests as requested (10 seconds by default)
|
||||
// Can be overridden by SEED_IMPORT_DELAY environment variable for testing
|
||||
if pageCount > 1 { // Don't delay before the first request
|
||||
delay := 10 * time.Second
|
||||
if delayStr := os.Getenv("SEED_IMPORT_DELAY"); delayStr != "" {
|
||||
if parsedDelay, err := time.ParseDuration(delayStr); err == nil {
|
||||
delay = parsedDelay
|
||||
}
|
||||
}
|
||||
if delay > 0 {
|
||||
log.Printf("Waiting %v before fetching page %d...", delay, pageCount)
|
||||
time.Sleep(delay)
|
||||
}
|
||||
}
|
||||
|
||||
log.Printf("Fetching page %d from registry", pageCount)
|
||||
|
||||
// Build the URL for this page
|
||||
serverURL := registryURL + "/v0/servers"
|
||||
url := baseURL
|
||||
if cursor != "" {
|
||||
// Add cursor parameter for pagination
|
||||
parsed, err := url.Parse(serverURL)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to parse registry URL: %w", err)
|
||||
if strings.Contains(url, "?") {
|
||||
url += "&cursor=" + cursor
|
||||
} else {
|
||||
url += "?cursor=" + cursor
|
||||
}
|
||||
query := parsed.Query()
|
||||
query.Set("cursor", cursor)
|
||||
query.Set("limit", "100") // Use maximum limit for efficiency
|
||||
parsed.RawQuery = query.Encode()
|
||||
serverURL = parsed.String()
|
||||
} else {
|
||||
// First page - use max limit
|
||||
serverURL += "?limit=100"
|
||||
}
|
||||
|
||||
// Fetch the page
|
||||
req, err := http.NewRequestWithContext(ctx, http.MethodGet, serverURL, nil)
|
||||
data, err := fetchFromHTTP(ctx, url)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to create request for %s: %w", serverURL, err)
|
||||
}
|
||||
resp, err := client.Do(req)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to fetch servers from %s: %w", serverURL, err)
|
||||
return nil, fmt.Errorf("failed to fetch page from registry API: %w", err)
|
||||
}
|
||||
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
resp.Body.Close()
|
||||
return nil, fmt.Errorf("HTTP request to %s failed with status %d: %s", serverURL, resp.StatusCode, resp.Status)
|
||||
var response struct {
|
||||
Servers []model.ServerResponse `json:"servers"`
|
||||
Metadata *struct {
|
||||
NextCursor string `json:"next_cursor,omitempty"`
|
||||
} `json:"metadata,omitempty"`
|
||||
}
|
||||
|
||||
// Read and parse the response
|
||||
body, err := io.ReadAll(resp.Body)
|
||||
resp.Body.Close()
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to read response body from %s: %w", serverURL, err)
|
||||
if err := json.Unmarshal(data, &response); err != nil {
|
||||
return nil, fmt.Errorf("failed to parse registry API response: %w", err)
|
||||
}
|
||||
|
||||
var pageResponse PaginatedResponse
|
||||
if err := json.Unmarshal(body, &pageResponse); err != nil {
|
||||
return nil, fmt.Errorf("failed to parse servers response from %s: %w", serverURL, err)
|
||||
// Convert and add servers
|
||||
for _, serverResponse := range response.Servers {
|
||||
record := convertServerResponseToRecord(serverResponse)
|
||||
allRecords = append(allRecords, record)
|
||||
}
|
||||
|
||||
log.Printf("Retrieved %d servers from page %d", len(pageResponse.Data), pageCount)
|
||||
|
||||
// For each server in this page, get the detailed information
|
||||
for _, server := range pageResponse.Data {
|
||||
// Build URL for server detail
|
||||
detailURL := registryURL + "/v0/servers/" + server.ID
|
||||
|
||||
detailReq, err := http.NewRequestWithContext(ctx, http.MethodGet, detailURL, nil)
|
||||
if err != nil {
|
||||
log.Printf("Warning: failed to create request for server %s: %v", server.ID, err)
|
||||
// Fall back to basic server information
|
||||
serverDetail := model.ServerDetail{
|
||||
Server: server,
|
||||
}
|
||||
allServers = append(allServers, serverDetail)
|
||||
continue
|
||||
}
|
||||
|
||||
detailResp, err := client.Do(detailReq)
|
||||
if err != nil {
|
||||
log.Printf("Warning: failed to fetch details for server %s: %v", server.ID, err)
|
||||
// Fall back to basic server information
|
||||
serverDetail := model.ServerDetail{
|
||||
Server: server,
|
||||
}
|
||||
allServers = append(allServers, serverDetail)
|
||||
continue
|
||||
}
|
||||
|
||||
if detailResp.StatusCode != http.StatusOK {
|
||||
log.Printf("Warning: failed to fetch details for server %s (status %d)", server.ID, detailResp.StatusCode)
|
||||
detailResp.Body.Close()
|
||||
// Fall back to basic server information
|
||||
serverDetail := model.ServerDetail{
|
||||
Server: server,
|
||||
}
|
||||
allServers = append(allServers, serverDetail)
|
||||
continue
|
||||
}
|
||||
|
||||
detailBody, err := io.ReadAll(detailResp.Body)
|
||||
detailResp.Body.Close()
|
||||
if err != nil {
|
||||
log.Printf("Warning: failed to read detail response for server %s: %v", server.ID, err)
|
||||
// Fall back to basic server information
|
||||
serverDetail := model.ServerDetail{
|
||||
Server: server,
|
||||
}
|
||||
allServers = append(allServers, serverDetail)
|
||||
continue
|
||||
}
|
||||
|
||||
var serverDetail model.ServerDetail
|
||||
if err := json.Unmarshal(detailBody, &serverDetail); err != nil {
|
||||
log.Printf("Warning: failed to parse detail response for server %s: %v", server.ID, err)
|
||||
// Fall back to basic server information
|
||||
serverDetail = model.ServerDetail{
|
||||
Server: server,
|
||||
}
|
||||
}
|
||||
|
||||
allServers = append(allServers, serverDetail)
|
||||
}
|
||||
|
||||
// Check if there are more pages
|
||||
if pageResponse.Metadata.NextCursor == "" {
|
||||
log.Printf("Reached end of pagination after %d pages", pageCount)
|
||||
// Check if there's a next page
|
||||
if response.Metadata == nil || response.Metadata.NextCursor == "" {
|
||||
break
|
||||
}
|
||||
|
||||
cursor = pageResponse.Metadata.NextCursor
|
||||
cursor = response.Metadata.NextCursor
|
||||
}
|
||||
|
||||
log.Printf("Successfully retrieved %d servers from registry %s", len(allServers), registryURL)
|
||||
return allServers, nil
|
||||
return allRecords, nil
|
||||
}
|
||||
|
||||
func convertServerResponseToRecord(response model.ServerResponse) *model.ServerRecord {
|
||||
// Extract registry metadata from the extension
|
||||
registryExt := response.XIOModelContextProtocolRegistry
|
||||
|
||||
// Parse timestamps
|
||||
publishedAt, _ := time.Parse(time.RFC3339, getStringFromInterface(registryExt, "published_at"))
|
||||
updatedAt, _ := time.Parse(time.RFC3339, getStringFromInterface(registryExt, "updated_at"))
|
||||
|
||||
registryMetadata := model.RegistryMetadata{
|
||||
ID: getStringFromInterface(registryExt, "id"),
|
||||
IsLatest: getBoolFromInterface(registryExt, "is_latest"),
|
||||
PublishedAt: publishedAt,
|
||||
UpdatedAt: updatedAt,
|
||||
ReleaseDate: getStringFromInterface(registryExt, "release_date"),
|
||||
}
|
||||
|
||||
// Publisher extensions
|
||||
publisherExtensions := make(map[string]interface{})
|
||||
if response.XPublisher != nil {
|
||||
if publisherMap, ok := response.XPublisher.(map[string]interface{}); ok {
|
||||
publisherExtensions = publisherMap
|
||||
}
|
||||
}
|
||||
|
||||
return &model.ServerRecord{
|
||||
ServerJSON: response.Server,
|
||||
RegistryMetadata: registryMetadata,
|
||||
PublisherExtensions: publisherExtensions,
|
||||
}
|
||||
}
|
||||
|
||||
func getStringFromInterface(data interface{}, key string) string {
|
||||
if dataMap, ok := data.(map[string]interface{}); ok {
|
||||
if value, exists := dataMap[key]; exists {
|
||||
if strValue, ok := value.(string); ok {
|
||||
return strValue
|
||||
}
|
||||
}
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func getBoolFromInterface(data interface{}, key string) bool {
|
||||
if dataMap, ok := data.(map[string]interface{}); ok {
|
||||
if value, exists := dataMap[key]; exists {
|
||||
if boolValue, ok := value.(bool); ok {
|
||||
return boolValue
|
||||
}
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
|
@ -14,12 +14,11 @@ import (
|
|||
)
|
||||
|
||||
func TestReadSeedFile_LocalFile(t *testing.T) {
|
||||
// Create a temporary seed file
|
||||
// Create a temporary seed file in extension wrapper format
|
||||
tempFile := "/tmp/test_seed.json"
|
||||
seedData := []model.ServerDetail{
|
||||
seedData := []model.ServerResponse{
|
||||
{
|
||||
Server: model.Server{
|
||||
ID: "test-id-1",
|
||||
Server: model.ServerDetail{
|
||||
Name: "test-server-1",
|
||||
Description: "Test server 1",
|
||||
Repository: model.Repository{
|
||||
|
|
@ -28,11 +27,14 @@ func TestReadSeedFile_LocalFile(t *testing.T) {
|
|||
ID: "123",
|
||||
},
|
||||
VersionDetail: model.VersionDetail{
|
||||
Version: "1.0.0",
|
||||
ReleaseDate: "2023-01-01T00:00:00Z",
|
||||
IsLatest: true,
|
||||
Version: "1.0.0",
|
||||
},
|
||||
},
|
||||
XIOModelContextProtocolRegistry: map[string]interface{}{
|
||||
"id": "test-id-1",
|
||||
"published_at": "2023-01-01T00:00:00Z",
|
||||
"is_latest": true,
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
|
|
@ -56,18 +58,22 @@ func TestReadSeedFile_LocalFile(t *testing.T) {
|
|||
result, err := database.ReadSeedFile(context.Background(), tempFile)
|
||||
assert.NoError(t, err)
|
||||
assert.Len(t, result, 1)
|
||||
assert.Equal(t, "test-server-1", result[0].Name)
|
||||
assert.Equal(t, "test-server-1", result[0].ServerJSON.Name)
|
||||
}
|
||||
|
||||
func TestReadSeedFile_DirectHTTPURL(t *testing.T) {
|
||||
// Create a test HTTP server that serves seed JSON directly
|
||||
seedData := []model.ServerDetail{
|
||||
// Create a test HTTP server that serves seed JSON directly in extension wrapper format
|
||||
seedData := []model.ServerResponse{
|
||||
{
|
||||
Server: model.Server{
|
||||
ID: "test-id-1",
|
||||
Server: model.ServerDetail{
|
||||
Name: "test-server-1",
|
||||
Description: "Test server 1",
|
||||
},
|
||||
XIOModelContextProtocolRegistry: map[string]interface{}{
|
||||
"id": "test-id-1",
|
||||
"published_at": "2023-01-01T00:00:00Z",
|
||||
"is_latest": true,
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
|
|
@ -83,35 +89,51 @@ func TestReadSeedFile_DirectHTTPURL(t *testing.T) {
|
|||
result, err := database.ReadSeedFile(context.Background(), server.URL+"/seed.json")
|
||||
assert.NoError(t, err)
|
||||
assert.Len(t, result, 1)
|
||||
assert.Equal(t, "test-server-1", result[0].Name)
|
||||
assert.Equal(t, "test-server-1", result[0].ServerJSON.Name)
|
||||
}
|
||||
|
||||
func TestReadSeedFile_RegistryURL(t *testing.T) {
|
||||
// Create mock registry servers
|
||||
server1 := model.Server{
|
||||
ID: "server-1",
|
||||
Name: "Test Server 1",
|
||||
Description: "First test server",
|
||||
// Create mock registry responses
|
||||
server1 := model.ServerResponse{
|
||||
Server: model.ServerDetail{
|
||||
Name: "Test Server 1",
|
||||
Description: "First test server",
|
||||
},
|
||||
XIOModelContextProtocolRegistry: map[string]interface{}{
|
||||
"id": "server-1",
|
||||
"published_at": "2023-01-01T00:00:00Z",
|
||||
"is_latest": true,
|
||||
},
|
||||
}
|
||||
server2 := model.Server{
|
||||
ID: "server-2",
|
||||
Name: "Test Server 2",
|
||||
Description: "Second test server",
|
||||
server2 := model.ServerResponse{
|
||||
Server: model.ServerDetail{
|
||||
Name: "Test Server 2",
|
||||
Description: "Second test server",
|
||||
},
|
||||
XIOModelContextProtocolRegistry: map[string]interface{}{
|
||||
"id": "server-2",
|
||||
"published_at": "2023-01-01T00:00:00Z",
|
||||
"is_latest": true,
|
||||
},
|
||||
}
|
||||
|
||||
serverDetail1 := model.ServerDetail{
|
||||
Server: server1,
|
||||
Name: "Test Server 1",
|
||||
Description: "First test server",
|
||||
Packages: []model.Package{
|
||||
{
|
||||
RegistryName: "npm",
|
||||
Name: "test-package-1",
|
||||
Version: "1.0.0",
|
||||
},
|
||||
},
|
||||
}
|
||||
serverDetail2 := model.ServerDetail{
|
||||
Server: server2,
|
||||
Name: "Test Server 2",
|
||||
Description: "Second test server",
|
||||
Packages: []model.Package{
|
||||
{
|
||||
RegistryName: "npm",
|
||||
Name: "test-package-2",
|
||||
Version: "2.0.0",
|
||||
},
|
||||
|
|
@ -125,22 +147,32 @@ func TestReadSeedFile_RegistryURL(t *testing.T) {
|
|||
mux.HandleFunc("/v0/servers", func(w http.ResponseWriter, r *http.Request) {
|
||||
cursor := r.URL.Query().Get("cursor")
|
||||
|
||||
var response database.PaginatedResponse
|
||||
type Metadata struct {
|
||||
NextCursor string `json:"next_cursor,omitempty"`
|
||||
Count int `json:"count,omitempty"`
|
||||
}
|
||||
|
||||
type PaginatedResponse struct {
|
||||
Servers []model.ServerResponse `json:"servers"`
|
||||
Metadata *Metadata `json:"metadata,omitempty"`
|
||||
}
|
||||
|
||||
var response PaginatedResponse
|
||||
switch cursor {
|
||||
case "":
|
||||
// First page
|
||||
response = database.PaginatedResponse{
|
||||
Data: []model.Server{server1},
|
||||
Metadata: database.Metadata{
|
||||
response = PaginatedResponse{
|
||||
Servers: []model.ServerResponse{server1},
|
||||
Metadata: &Metadata{
|
||||
NextCursor: "next-cursor-1",
|
||||
Count: 1,
|
||||
},
|
||||
}
|
||||
case "next-cursor-1":
|
||||
// Second page
|
||||
response = database.PaginatedResponse{
|
||||
Data: []model.Server{server2},
|
||||
Metadata: database.Metadata{
|
||||
response = PaginatedResponse{
|
||||
Servers: []model.ServerResponse{server2},
|
||||
Metadata: &Metadata{
|
||||
Count: 1,
|
||||
// No NextCursor means end of pagination
|
||||
},
|
||||
|
|
@ -172,17 +204,15 @@ func TestReadSeedFile_RegistryURL(t *testing.T) {
|
|||
defer server.Close()
|
||||
|
||||
// Test reading from registry root URL (this should trigger pagination)
|
||||
result, err := database.ReadSeedFile(context.Background(), server.URL)
|
||||
result, err := database.ReadSeedFile(context.Background(), server.URL+"/v0/servers")
|
||||
assert.NoError(t, err)
|
||||
assert.Len(t, result, 2)
|
||||
|
||||
// Verify the servers were imported correctly
|
||||
assert.Equal(t, "Test Server 1", result[0].Name)
|
||||
assert.Equal(t, "Test Server 2", result[1].Name)
|
||||
assert.Equal(t, "Test Server 1", result[0].ServerJSON.Name)
|
||||
assert.Equal(t, "Test Server 2", result[1].ServerJSON.Name)
|
||||
|
||||
// Verify packages were included
|
||||
assert.Len(t, result[0].Packages, 1)
|
||||
assert.Equal(t, "test-package-1", result[0].Packages[0].Name)
|
||||
assert.Len(t, result[1].Packages, 1)
|
||||
assert.Equal(t, "test-package-2", result[1].Packages[0].Name)
|
||||
}
|
||||
// Verify metadata was extracted
|
||||
assert.Equal(t, "server-1", result[0].RegistryMetadata.ID)
|
||||
assert.Equal(t, "server-2", result[1].RegistryMetadata.ID)
|
||||
}
|
||||
|
|
@ -3,7 +3,6 @@ package database
|
|||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"log"
|
||||
"sort"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
|
@ -16,21 +15,32 @@ import (
|
|||
|
||||
// MemoryDB is an in-memory implementation of the Database interface
|
||||
type MemoryDB struct {
|
||||
entries map[string]*model.ServerDetail
|
||||
entries map[string]*model.ServerRecord // maps registry metadata ID to ServerRecord
|
||||
mu sync.RWMutex
|
||||
}
|
||||
|
||||
// NewMemoryDB creates a new instance of the in-memory database
|
||||
func NewMemoryDB(e map[string]*model.Server) *MemoryDB {
|
||||
// Convert Server entries to ServerDetail entries
|
||||
serverDetails := make(map[string]*model.ServerDetail)
|
||||
for k, v := range e {
|
||||
serverDetails[k] = &model.ServerDetail{
|
||||
Server: *v,
|
||||
func NewMemoryDB(e map[string]*model.ServerDetail) *MemoryDB {
|
||||
// Convert ServerDetail entries to ServerRecord entries
|
||||
serverRecords := make(map[string]*model.ServerRecord)
|
||||
for registryID, serverDetail := range e {
|
||||
// Create registry metadata
|
||||
now := time.Now()
|
||||
record := &model.ServerRecord{
|
||||
ServerJSON: *serverDetail,
|
||||
RegistryMetadata: model.RegistryMetadata{
|
||||
ID: registryID,
|
||||
PublishedAt: now,
|
||||
UpdatedAt: now,
|
||||
IsLatest: true,
|
||||
ReleaseDate: now.Format(time.RFC3339),
|
||||
},
|
||||
PublisherExtensions: make(map[string]interface{}),
|
||||
}
|
||||
serverRecords[registryID] = record
|
||||
}
|
||||
return &MemoryDB{
|
||||
entries: serverDetails,
|
||||
entries: serverRecords,
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -82,15 +92,13 @@ func compareSemanticVersions(version1, version2 string) int {
|
|||
return 0
|
||||
}
|
||||
|
||||
// List retrieves all MCPRegistry entries with optional filtering and pagination
|
||||
//
|
||||
//gocognit:ignore
|
||||
// List retrieves ServerRecord entries with optional filtering and pagination
|
||||
func (db *MemoryDB) List(
|
||||
ctx context.Context,
|
||||
filter map[string]any,
|
||||
cursor string,
|
||||
limit int,
|
||||
) ([]*model.Server, string, error) {
|
||||
) ([]*model.ServerRecord, string, error) {
|
||||
if ctx.Err() != nil {
|
||||
return nil, "", ctx.Err()
|
||||
}
|
||||
|
|
@ -101,16 +109,18 @@ func (db *MemoryDB) List(
|
|||
|
||||
db.mu.RLock()
|
||||
defer db.mu.RUnlock()
|
||||
|
||||
|
||||
// Convert all entries to a slice for pagination
|
||||
var allEntries []*model.Server
|
||||
// Convert all entries to a slice for pagination, filter by is_latest
|
||||
var allEntries []*model.ServerRecord
|
||||
for _, entry := range db.entries {
|
||||
serverCopy := entry.Server
|
||||
allEntries = append(allEntries, &serverCopy)
|
||||
if entry.RegistryMetadata.IsLatest {
|
||||
allEntries = append(allEntries, entry)
|
||||
}
|
||||
}
|
||||
|
||||
// Simple filtering implementation
|
||||
var filteredEntries []*model.Server
|
||||
var filteredEntries []*model.ServerRecord
|
||||
for _, entry := range allEntries {
|
||||
include := true
|
||||
|
||||
|
|
@ -118,22 +128,17 @@ func (db *MemoryDB) List(
|
|||
for key, value := range filter {
|
||||
switch key {
|
||||
case "name":
|
||||
if entry.Name != value.(string) {
|
||||
include = false
|
||||
}
|
||||
case "repoUrl":
|
||||
if entry.Repository.URL != value.(string) {
|
||||
include = false
|
||||
}
|
||||
case "serverDetail.id":
|
||||
if entry.ID != value.(string) {
|
||||
if entry.ServerJSON.Name != value.(string) {
|
||||
include = false
|
||||
}
|
||||
case "version":
|
||||
if entry.VersionDetail.Version != value.(string) {
|
||||
if entry.ServerJSON.VersionDetail.Version != value.(string) {
|
||||
include = false
|
||||
}
|
||||
case "status":
|
||||
if string(entry.ServerJSON.Status) != value.(string) {
|
||||
include = false
|
||||
}
|
||||
// Add more filter options as needed
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -142,43 +147,43 @@ func (db *MemoryDB) List(
|
|||
}
|
||||
}
|
||||
|
||||
// Find starting point for cursor-based pagination
|
||||
// Sort filteredEntries by registry metadata ID for consistent pagination
|
||||
sort.Slice(filteredEntries, func(i, j int) bool {
|
||||
return filteredEntries[i].RegistryMetadata.ID < filteredEntries[j].RegistryMetadata.ID
|
||||
})
|
||||
|
||||
// Find starting point for cursor-based pagination using registry metadata ID
|
||||
startIdx := 0
|
||||
if cursor != "" {
|
||||
for i, entry := range filteredEntries {
|
||||
if entry.ID == cursor {
|
||||
if entry.RegistryMetadata.ID == cursor {
|
||||
startIdx = i + 1 // Start after the cursor
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Sort filteredEntries by ID for consistent pagination
|
||||
sort.Slice(filteredEntries, func(i, j int) bool {
|
||||
return filteredEntries[i].ID < filteredEntries[j].ID
|
||||
})
|
||||
|
||||
// Apply pagination
|
||||
endIdx := min(startIdx+limit, len(filteredEntries))
|
||||
|
||||
var result []*model.Server
|
||||
var result []*model.ServerRecord
|
||||
if startIdx < len(filteredEntries) {
|
||||
result = filteredEntries[startIdx:endIdx]
|
||||
} else {
|
||||
result = []*model.Server{}
|
||||
result = []*model.ServerRecord{}
|
||||
}
|
||||
|
||||
// Determine next cursor
|
||||
// Determine next cursor using registry metadata ID
|
||||
nextCursor := ""
|
||||
if endIdx < len(filteredEntries) {
|
||||
nextCursor = filteredEntries[endIdx-1].ID
|
||||
nextCursor = filteredEntries[endIdx-1].RegistryMetadata.ID
|
||||
}
|
||||
|
||||
return result, nextCursor, nil
|
||||
}
|
||||
|
||||
// GetByID retrieves a single ServerDetail by its ID
|
||||
func (db *MemoryDB) GetByID(ctx context.Context, id string) (*model.ServerDetail, error) {
|
||||
// GetByID retrieves a single ServerRecord by its registry metadata ID
|
||||
func (db *MemoryDB) GetByID(ctx context.Context, id string) (*model.ServerRecord, error) {
|
||||
if ctx.Err() != nil {
|
||||
return nil, ctx.Err()
|
||||
}
|
||||
|
|
@ -186,66 +191,84 @@ func (db *MemoryDB) GetByID(ctx context.Context, id string) (*model.ServerDetail
|
|||
db.mu.RLock()
|
||||
defer db.mu.RUnlock()
|
||||
|
||||
// Find entry by registry metadata ID
|
||||
if entry, exists := db.entries[id]; exists {
|
||||
// Return a copy of the ServerDetail
|
||||
serverDetailCopy := *entry
|
||||
return &serverDetailCopy, nil
|
||||
// Return a copy of the ServerRecord
|
||||
entryCopy := *entry
|
||||
return &entryCopy, nil
|
||||
}
|
||||
|
||||
return nil, ErrNotFound
|
||||
}
|
||||
|
||||
// Publish adds a new ServerDetail to the database
|
||||
func (db *MemoryDB) Publish(ctx context.Context, serverDetail *model.ServerDetail) error {
|
||||
// Publish adds a new server to the database with separated server.json and extensions
|
||||
func (db *MemoryDB) Publish(ctx context.Context, serverDetail model.ServerDetail, publisherExtensions map[string]interface{}) (*model.ServerRecord, error) {
|
||||
if ctx.Err() != nil {
|
||||
return ctx.Err()
|
||||
return nil, ctx.Err()
|
||||
}
|
||||
|
||||
// Extract name and version for validation
|
||||
name := serverDetail.Name
|
||||
if name == "" {
|
||||
return nil, fmt.Errorf("name is required in server JSON")
|
||||
}
|
||||
|
||||
version := serverDetail.VersionDetail.Version
|
||||
if version == "" {
|
||||
return nil, fmt.Errorf("version is required in version_detail")
|
||||
}
|
||||
|
||||
db.mu.Lock()
|
||||
defer db.mu.Unlock()
|
||||
|
||||
// check for name
|
||||
if serverDetail.Name == "" {
|
||||
return ErrInvalidInput
|
||||
}
|
||||
|
||||
// check that the name and the version are unique
|
||||
// Also check version ordering - don't allow publishing older versions after newer ones
|
||||
var latestVersion string
|
||||
// Check for existing entry with same name and compare versions
|
||||
var existingRecord *model.ServerRecord
|
||||
for _, entry := range db.entries {
|
||||
if entry.Name == serverDetail.Name {
|
||||
if entry.VersionDetail.Version == serverDetail.VersionDetail.Version {
|
||||
return ErrAlreadyExists
|
||||
}
|
||||
|
||||
// Track the latest version for this package name
|
||||
if latestVersion == "" || compareSemanticVersions(entry.VersionDetail.Version, latestVersion) > 0 {
|
||||
latestVersion = entry.VersionDetail.Version
|
||||
}
|
||||
if entry.RegistryMetadata.IsLatest && entry.ServerJSON.Name == name {
|
||||
existingRecord = entry
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
// If we found existing versions, check if the new version is older than the latest
|
||||
if latestVersion != "" && compareSemanticVersions(serverDetail.VersionDetail.Version, latestVersion) < 0 {
|
||||
return ErrInvalidVersion
|
||||
// Version comparison
|
||||
if existingRecord != nil {
|
||||
existingVersion := existingRecord.ServerJSON.VersionDetail.Version
|
||||
if compareSemanticVersions(version, existingVersion) <= 0 {
|
||||
return nil, fmt.Errorf("version must be greater than existing version %s", existingVersion)
|
||||
}
|
||||
}
|
||||
|
||||
// Validate repository URL
|
||||
if serverDetail.Repository.URL == "" {
|
||||
return ErrInvalidInput
|
||||
return nil, ErrInvalidInput
|
||||
}
|
||||
|
||||
// Always generate a new UUID for the ID
|
||||
serverDetail.ID = uuid.New().String()
|
||||
serverDetail.VersionDetail.IsLatest = true // Assume the new version is the latest
|
||||
// Only set ReleaseDate if it's not already provided
|
||||
if serverDetail.VersionDetail.ReleaseDate == "" {
|
||||
serverDetail.VersionDetail.ReleaseDate = time.Now().Format(time.RFC3339)
|
||||
// Create new registry metadata
|
||||
now := time.Now()
|
||||
registryMetadata := model.RegistryMetadata{
|
||||
ID: uuid.New().String(),
|
||||
PublishedAt: now,
|
||||
UpdatedAt: now,
|
||||
IsLatest: true,
|
||||
ReleaseDate: now.Format(time.RFC3339),
|
||||
}
|
||||
// Store a copy of the entire ServerDetail
|
||||
serverDetailCopy := *serverDetail
|
||||
db.entries[serverDetail.ID] = &serverDetailCopy
|
||||
|
||||
return nil
|
||||
// Create server record
|
||||
record := &model.ServerRecord{
|
||||
ServerJSON: serverDetail,
|
||||
RegistryMetadata: registryMetadata,
|
||||
PublisherExtensions: publisherExtensions,
|
||||
}
|
||||
|
||||
// Mark existing record as not latest
|
||||
if existingRecord != nil {
|
||||
existingRecord.RegistryMetadata.IsLatest = false
|
||||
}
|
||||
|
||||
// Store the record using registry metadata ID
|
||||
db.entries[registryMetadata.ID] = record
|
||||
|
||||
return record, nil
|
||||
}
|
||||
|
||||
// ImportSeed imports initial data from a seed file into memory database
|
||||
|
|
@ -253,39 +276,25 @@ func (db *MemoryDB) ImportSeed(ctx context.Context, seedFilePath string) error {
|
|||
if ctx.Err() != nil {
|
||||
return ctx.Err()
|
||||
}
|
||||
|
||||
// Read the seed file
|
||||
|
||||
// This will need to be updated to work with the new ServerRecord format
|
||||
// Read seed data using the shared ReadSeedFile function
|
||||
seedData, err := ReadSeedFile(ctx, seedFilePath)
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to read seed file: %w", err)
|
||||
}
|
||||
|
||||
log.Printf("Importing %d servers into memory database", len(seedData))
|
||||
|
||||
// Lock for concurrent access
|
||||
db.mu.Lock()
|
||||
defer db.mu.Unlock()
|
||||
|
||||
for i, server := range seedData {
|
||||
if server.ID == "" || server.Name == "" {
|
||||
log.Printf("Skipping server %d: ID or Name is empty", i+1)
|
||||
continue
|
||||
}
|
||||
|
||||
// Set default version information if missing
|
||||
if server.VersionDetail.Version == "" {
|
||||
server.VersionDetail.Version = "0.0.1-seed"
|
||||
server.VersionDetail.ReleaseDate = time.Now().Format(time.RFC3339)
|
||||
server.VersionDetail.IsLatest = true
|
||||
}
|
||||
|
||||
// Store a copy of the server detail
|
||||
serverDetailCopy := server
|
||||
db.entries[server.ID] = &serverDetailCopy
|
||||
|
||||
log.Printf("[%d/%d] Imported server: %s", i+1, len(seedData), server.Name)
|
||||
// Import each server
|
||||
for _, record := range seedData {
|
||||
// Use the registry metadata ID as the map key
|
||||
db.entries[record.RegistryMetadata.ID] = record
|
||||
}
|
||||
|
||||
|
||||
log.Println("Memory database import completed successfully")
|
||||
return nil
|
||||
}
|
||||
|
||||
|
|
@ -302,4 +311,4 @@ func (db *MemoryDB) Connection() *ConnectionInfo {
|
|||
IsConnected: true, // Memory DB is always connected
|
||||
Raw: db.entries,
|
||||
}
|
||||
}
|
||||
}
|
||||
62
internal/database/migrations/002_add_server_extensions.sql
Normal file
62
internal/database/migrations/002_add_server_extensions.sql
Normal file
|
|
@ -0,0 +1,62 @@
|
|||
-- Add server_extensions table for registry metadata and publisher extensions
|
||||
-- This migration implements the extension wrapper architecture
|
||||
|
||||
-- Create server_extensions table for registry/publisher metadata
|
||||
CREATE TABLE server_extensions (
|
||||
id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
|
||||
server_id UUID NOT NULL REFERENCES servers(id) ON DELETE CASCADE,
|
||||
|
||||
-- Registry metadata as structured columns
|
||||
published_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW(),
|
||||
updated_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW(),
|
||||
is_latest BOOLEAN NOT NULL DEFAULT true,
|
||||
release_date TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW(),
|
||||
|
||||
-- Publisher extensions as flexible JSONB
|
||||
publisher_extensions JSONB DEFAULT '{}'::jsonb,
|
||||
|
||||
-- Ensure one extension record per server
|
||||
UNIQUE(server_id)
|
||||
);
|
||||
|
||||
-- Indexes for performance
|
||||
CREATE UNIQUE INDEX idx_server_extensions_server_id ON server_extensions(server_id);
|
||||
CREATE INDEX idx_server_extensions_latest ON server_extensions(is_latest) WHERE is_latest = true;
|
||||
CREATE INDEX idx_server_extensions_published_at ON server_extensions(published_at);
|
||||
|
||||
-- GIN index for publisher extensions JSONB field
|
||||
CREATE INDEX idx_server_extensions_publisher_gin ON server_extensions USING GIN(publisher_extensions);
|
||||
|
||||
-- Migrate existing data from servers table to server_extensions table
|
||||
INSERT INTO server_extensions (server_id, published_at, updated_at, is_latest, release_date, publisher_extensions)
|
||||
SELECT
|
||||
id,
|
||||
created_at, -- Use created_at as published_at
|
||||
updated_at,
|
||||
is_latest,
|
||||
release_date,
|
||||
'{}'::jsonb -- Empty publisher extensions
|
||||
FROM servers;
|
||||
|
||||
-- Remove registry metadata columns from servers table (they now live in server_extensions)
|
||||
ALTER TABLE servers DROP COLUMN release_date;
|
||||
ALTER TABLE servers DROP COLUMN is_latest;
|
||||
|
||||
-- Update trigger to also update server_extensions updated_at when servers are updated
|
||||
CREATE OR REPLACE FUNCTION update_server_extensions_updated_at()
|
||||
RETURNS TRIGGER AS $$
|
||||
BEGIN
|
||||
-- Update the corresponding server_extensions record
|
||||
UPDATE server_extensions
|
||||
SET updated_at = NOW()
|
||||
WHERE server_id = NEW.id;
|
||||
|
||||
RETURN NEW;
|
||||
END;
|
||||
$$ language 'plpgsql';
|
||||
|
||||
-- Trigger to automatically update server_extensions updated_at when servers change
|
||||
CREATE TRIGGER update_server_extensions_on_server_update
|
||||
AFTER UPDATE ON servers
|
||||
FOR EACH ROW
|
||||
EXECUTE FUNCTION update_server_extensions_updated_at();
|
||||
|
|
@ -41,13 +41,13 @@ func NewPostgreSQL(ctx context.Context, connectionURI string) (*PostgreSQL, erro
|
|||
}, nil
|
||||
}
|
||||
|
||||
// List retrieves MCPRegistry entries with optional filtering and pagination
|
||||
// List retrieves ServerRecord entries with optional filtering and pagination
|
||||
func (db *PostgreSQL) List(
|
||||
ctx context.Context,
|
||||
filter map[string]any,
|
||||
cursor string,
|
||||
limit int,
|
||||
) ([]*model.Server, string, error) {
|
||||
) ([]*model.ServerRecord, string, error) {
|
||||
if limit <= 0 {
|
||||
limit = 10
|
||||
}
|
||||
|
|
@ -56,8 +56,8 @@ func (db *PostgreSQL) List(
|
|||
return nil, "", ctx.Err()
|
||||
}
|
||||
|
||||
// Build WHERE clause
|
||||
whereClause := "WHERE is_latest = true"
|
||||
// Build WHERE clause for server_extensions filtering
|
||||
whereClause := "WHERE se.is_latest = true"
|
||||
args := []any{}
|
||||
argIndex := 1
|
||||
|
||||
|
|
@ -65,162 +65,225 @@ func (db *PostgreSQL) List(
|
|||
for k, v := range filter {
|
||||
switch k {
|
||||
case "name":
|
||||
whereClause += fmt.Sprintf(" AND name = $%d", argIndex)
|
||||
whereClause += fmt.Sprintf(" AND s.name = $%d", argIndex)
|
||||
args = append(args, v)
|
||||
argIndex++
|
||||
case "version":
|
||||
whereClause += fmt.Sprintf(" AND version = $%d", argIndex)
|
||||
whereClause += fmt.Sprintf(" AND s.version = $%d", argIndex)
|
||||
args = append(args, v)
|
||||
argIndex++
|
||||
case "status":
|
||||
whereClause += fmt.Sprintf(" AND status = $%d", argIndex)
|
||||
whereClause += fmt.Sprintf(" AND s.status = $%d", argIndex)
|
||||
args = append(args, v)
|
||||
argIndex++
|
||||
}
|
||||
}
|
||||
|
||||
// Add cursor pagination
|
||||
// Add cursor pagination using registry metadata ID
|
||||
if cursor != "" {
|
||||
if _, err := uuid.Parse(cursor); err != nil {
|
||||
return nil, "", fmt.Errorf("invalid cursor format: %w", err)
|
||||
}
|
||||
whereClause += fmt.Sprintf(" AND id > $%d", argIndex)
|
||||
whereClause += fmt.Sprintf(" AND se.id > $%d", argIndex)
|
||||
args = append(args, cursor)
|
||||
argIndex++
|
||||
}
|
||||
|
||||
// Build query
|
||||
// Build JOIN query between servers and server_extensions
|
||||
query := fmt.Sprintf(`
|
||||
SELECT id, name, description, status, repository, version, release_date, is_latest
|
||||
FROM servers
|
||||
SELECT
|
||||
s.name, s.description, s.status, s.repository, s.version, s.packages, s.remotes,
|
||||
se.id, se.published_at, se.updated_at, se.is_latest, se.release_date, se.publisher_extensions
|
||||
FROM servers s
|
||||
JOIN server_extensions se ON s.id = se.server_id
|
||||
%s
|
||||
ORDER BY id
|
||||
ORDER BY se.id
|
||||
LIMIT $%d
|
||||
`, whereClause, argIndex)
|
||||
args = append(args, limit)
|
||||
|
||||
rows, err := db.conn.Query(ctx, query, args...)
|
||||
if err != nil {
|
||||
return nil, "", fmt.Errorf("failed to query servers: %w", err)
|
||||
return nil, "", fmt.Errorf("failed to query servers with extensions: %w", err)
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
var results []*model.Server
|
||||
var results []*model.ServerRecord
|
||||
for rows.Next() {
|
||||
var server model.Server
|
||||
var repositoryJSON []byte
|
||||
var releaseDate time.Time
|
||||
var record model.ServerRecord
|
||||
var repositoryJSON, packagesJSON, remotesJSON, publisherExtensionsJSON []byte
|
||||
var publishedAt, updatedAt, releaseDate time.Time
|
||||
|
||||
err := rows.Scan(
|
||||
&server.ID,
|
||||
&server.Name,
|
||||
&server.Description,
|
||||
&server.Status,
|
||||
// Server fields
|
||||
&record.ServerJSON.Name,
|
||||
&record.ServerJSON.Description,
|
||||
&record.ServerJSON.Status,
|
||||
&repositoryJSON,
|
||||
&server.VersionDetail.Version,
|
||||
&record.ServerJSON.VersionDetail.Version,
|
||||
&packagesJSON,
|
||||
&remotesJSON,
|
||||
// Registry metadata fields
|
||||
&record.RegistryMetadata.ID,
|
||||
&publishedAt,
|
||||
&updatedAt,
|
||||
&record.RegistryMetadata.IsLatest,
|
||||
&releaseDate,
|
||||
&server.VersionDetail.IsLatest,
|
||||
&publisherExtensionsJSON,
|
||||
)
|
||||
if err != nil {
|
||||
return nil, "", fmt.Errorf("failed to scan server row: %w", err)
|
||||
return nil, "", fmt.Errorf("failed to scan server record row: %w", err)
|
||||
}
|
||||
|
||||
// Parse repository JSON
|
||||
if len(repositoryJSON) > 0 {
|
||||
if err := json.Unmarshal(repositoryJSON, &server.Repository); err != nil {
|
||||
return nil, "", fmt.Errorf("failed to unmarshal repository: %w", err)
|
||||
}
|
||||
// Parse JSON fields
|
||||
if err := parseJSONFields(&record, repositoryJSON, packagesJSON, remotesJSON, publisherExtensionsJSON); err != nil {
|
||||
return nil, "", err
|
||||
}
|
||||
|
||||
server.VersionDetail.ReleaseDate = releaseDate.Format(time.RFC3339)
|
||||
results = append(results, &server)
|
||||
// Set registry metadata timestamps
|
||||
record.RegistryMetadata.PublishedAt = publishedAt
|
||||
record.RegistryMetadata.UpdatedAt = updatedAt
|
||||
record.RegistryMetadata.ReleaseDate = releaseDate.Format(time.RFC3339)
|
||||
|
||||
results = append(results, &record)
|
||||
}
|
||||
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, "", fmt.Errorf("error iterating rows: %w", err)
|
||||
}
|
||||
|
||||
// Determine next cursor
|
||||
// Determine next cursor using registry metadata ID
|
||||
nextCursor := ""
|
||||
if len(results) > 0 && len(results) >= limit {
|
||||
nextCursor = results[len(results)-1].ID
|
||||
nextCursor = results[len(results)-1].RegistryMetadata.ID
|
||||
}
|
||||
|
||||
return results, nextCursor, nil
|
||||
}
|
||||
|
||||
// GetByID retrieves a single ServerDetail by its ID
|
||||
func (db *PostgreSQL) GetByID(ctx context.Context, id string) (*model.ServerDetail, error) {
|
||||
// parseJSONFields parses JSON fields for a server record
|
||||
func parseJSONFields(record *model.ServerRecord, repositoryJSON, packagesJSON, remotesJSON, publisherExtensionsJSON []byte) error {
|
||||
if len(repositoryJSON) > 0 {
|
||||
if err := json.Unmarshal(repositoryJSON, &record.ServerJSON.Repository); err != nil {
|
||||
return fmt.Errorf("failed to unmarshal repository: %w", err)
|
||||
}
|
||||
}
|
||||
|
||||
if len(packagesJSON) > 0 {
|
||||
if err := json.Unmarshal(packagesJSON, &record.ServerJSON.Packages); err != nil {
|
||||
return fmt.Errorf("failed to unmarshal packages: %w", err)
|
||||
}
|
||||
}
|
||||
|
||||
if len(remotesJSON) > 0 {
|
||||
if err := json.Unmarshal(remotesJSON, &record.ServerJSON.Remotes); err != nil {
|
||||
return fmt.Errorf("failed to unmarshal remotes: %w", err)
|
||||
}
|
||||
}
|
||||
|
||||
if len(publisherExtensionsJSON) > 0 {
|
||||
if err := json.Unmarshal(publisherExtensionsJSON, &record.PublisherExtensions); err != nil {
|
||||
return fmt.Errorf("failed to unmarshal publisher extensions: %w", err)
|
||||
}
|
||||
} else {
|
||||
record.PublisherExtensions = make(map[string]interface{})
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// GetByID retrieves a single ServerRecord by its registry metadata ID
|
||||
func (db *PostgreSQL) GetByID(ctx context.Context, id string) (*model.ServerRecord, error) {
|
||||
if ctx.Err() != nil {
|
||||
return nil, ctx.Err()
|
||||
}
|
||||
|
||||
query := `
|
||||
SELECT id, name, description, status, repository, version, release_date, is_latest, packages, remotes
|
||||
FROM servers
|
||||
WHERE id = $1
|
||||
SELECT
|
||||
s.name, s.description, s.status, s.repository, s.version, s.packages, s.remotes,
|
||||
se.id, se.published_at, se.updated_at, se.is_latest, se.release_date, se.publisher_extensions
|
||||
FROM servers s
|
||||
JOIN server_extensions se ON s.id = se.server_id
|
||||
WHERE se.id = $1
|
||||
`
|
||||
|
||||
var serverDetail model.ServerDetail
|
||||
var repositoryJSON, packagesJSON, remotesJSON []byte
|
||||
var releaseDate time.Time
|
||||
var record model.ServerRecord
|
||||
var repositoryJSON, packagesJSON, remotesJSON, publisherExtensionsJSON []byte
|
||||
var publishedAt, updatedAt, releaseDate time.Time
|
||||
|
||||
err := db.conn.QueryRow(ctx, query, id).Scan(
|
||||
&serverDetail.ID,
|
||||
&serverDetail.Name,
|
||||
&serverDetail.Description,
|
||||
&serverDetail.Status,
|
||||
// Server fields
|
||||
&record.ServerJSON.Name,
|
||||
&record.ServerJSON.Description,
|
||||
&record.ServerJSON.Status,
|
||||
&repositoryJSON,
|
||||
&serverDetail.VersionDetail.Version,
|
||||
&releaseDate,
|
||||
&serverDetail.VersionDetail.IsLatest,
|
||||
&record.ServerJSON.VersionDetail.Version,
|
||||
&packagesJSON,
|
||||
&remotesJSON,
|
||||
// Registry metadata fields
|
||||
&record.RegistryMetadata.ID,
|
||||
&publishedAt,
|
||||
&updatedAt,
|
||||
&record.RegistryMetadata.IsLatest,
|
||||
&releaseDate,
|
||||
&publisherExtensionsJSON,
|
||||
)
|
||||
|
||||
if err != nil {
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return nil, ErrNotFound
|
||||
}
|
||||
return nil, fmt.Errorf("failed to get server by ID: %w", err)
|
||||
return nil, fmt.Errorf("failed to get server record by ID: %w", err)
|
||||
}
|
||||
|
||||
// Parse JSON fields
|
||||
if len(repositoryJSON) > 0 {
|
||||
if err := json.Unmarshal(repositoryJSON, &serverDetail.Repository); err != nil {
|
||||
if err := json.Unmarshal(repositoryJSON, &record.ServerJSON.Repository); err != nil {
|
||||
return nil, fmt.Errorf("failed to unmarshal repository: %w", err)
|
||||
}
|
||||
}
|
||||
|
||||
if len(packagesJSON) > 0 {
|
||||
if err := json.Unmarshal(packagesJSON, &serverDetail.Packages); err != nil {
|
||||
if err := json.Unmarshal(packagesJSON, &record.ServerJSON.Packages); err != nil {
|
||||
return nil, fmt.Errorf("failed to unmarshal packages: %w", err)
|
||||
}
|
||||
}
|
||||
|
||||
if len(remotesJSON) > 0 {
|
||||
if err := json.Unmarshal(remotesJSON, &serverDetail.Remotes); err != nil {
|
||||
if err := json.Unmarshal(remotesJSON, &record.ServerJSON.Remotes); err != nil {
|
||||
return nil, fmt.Errorf("failed to unmarshal remotes: %w", err)
|
||||
}
|
||||
}
|
||||
|
||||
serverDetail.VersionDetail.ReleaseDate = releaseDate.Format(time.RFC3339)
|
||||
// Parse publisher extensions
|
||||
if len(publisherExtensionsJSON) > 0 {
|
||||
if err := json.Unmarshal(publisherExtensionsJSON, &record.PublisherExtensions); err != nil {
|
||||
return nil, fmt.Errorf("failed to unmarshal publisher extensions: %w", err)
|
||||
}
|
||||
} else {
|
||||
record.PublisherExtensions = make(map[string]interface{})
|
||||
}
|
||||
|
||||
return &serverDetail, nil
|
||||
// Set registry metadata timestamps
|
||||
record.RegistryMetadata.PublishedAt = publishedAt
|
||||
record.RegistryMetadata.UpdatedAt = updatedAt
|
||||
record.RegistryMetadata.ReleaseDate = releaseDate.Format(time.RFC3339)
|
||||
|
||||
return &record, nil
|
||||
}
|
||||
|
||||
// Publish adds a new ServerDetail to the database
|
||||
func (db *PostgreSQL) Publish(ctx context.Context, serverDetail *model.ServerDetail) error {
|
||||
// Publish adds a new server to the database with separated server.json and extensions
|
||||
func (db *PostgreSQL) Publish(ctx context.Context, serverDetail model.ServerDetail, publisherExtensions map[string]interface{}) (*model.ServerRecord, error) {
|
||||
if ctx.Err() != nil {
|
||||
return ctx.Err()
|
||||
return nil, ctx.Err()
|
||||
}
|
||||
|
||||
tx, err := db.conn.Begin(ctx)
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to begin transaction: %w", err)
|
||||
return nil, fmt.Errorf("failed to begin transaction: %w", err)
|
||||
}
|
||||
defer func() {
|
||||
if err := tx.Rollback(ctx); err != nil {
|
||||
if err := tx.Rollback(ctx); err != nil && !errors.Is(err, pgx.ErrTxClosed) {
|
||||
log.Printf("Failed to rollback transaction: %v", err)
|
||||
}
|
||||
}()
|
||||
|
|
@ -228,26 +291,176 @@ func (db *PostgreSQL) Publish(ctx context.Context, serverDetail *model.ServerDet
|
|||
// Check if there's an existing latest version for this server
|
||||
var existingVersion string
|
||||
checkQuery := `
|
||||
SELECT version
|
||||
FROM servers
|
||||
WHERE name = $1 AND is_latest = true
|
||||
SELECT s.version
|
||||
FROM servers s
|
||||
JOIN server_extensions se ON s.id = se.server_id
|
||||
WHERE s.name = $1 AND se.is_latest = true
|
||||
`
|
||||
err = tx.QueryRow(ctx, checkQuery, serverDetail.Name).Scan(&existingVersion)
|
||||
if err != nil && !errors.Is(err, pgx.ErrNoRows) {
|
||||
return fmt.Errorf("failed to check existing version: %w", err)
|
||||
return nil, fmt.Errorf("failed to check existing version: %w", err)
|
||||
}
|
||||
|
||||
// Validate version ordering
|
||||
if existingVersion != "" && serverDetail.VersionDetail.Version <= existingVersion {
|
||||
return ErrInvalidVersion
|
||||
return nil, ErrInvalidVersion
|
||||
}
|
||||
|
||||
// Prepare JSON data
|
||||
// Prepare JSON data for server table
|
||||
repositoryJSON, err := json.Marshal(serverDetail.Repository)
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to marshal repository: %w", err)
|
||||
return nil, fmt.Errorf("failed to marshal repository: %w", err)
|
||||
}
|
||||
|
||||
packagesJSON, err := json.Marshal(serverDetail.Packages)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to marshal packages: %w", err)
|
||||
}
|
||||
|
||||
remotesJSON, err := json.Marshal(serverDetail.Remotes)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to marshal remotes: %w", err)
|
||||
}
|
||||
|
||||
publisherExtensionsJSON, err := json.Marshal(publisherExtensions)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to marshal publisher extensions: %w", err)
|
||||
}
|
||||
|
||||
// Generate server ID and create registry metadata
|
||||
serverID := uuid.New().String()
|
||||
registryID := uuid.New().String()
|
||||
now := time.Now()
|
||||
|
||||
// Update existing latest version to not be latest
|
||||
if existingVersion != "" {
|
||||
updateQuery := `
|
||||
UPDATE server_extensions
|
||||
SET is_latest = false
|
||||
WHERE server_id IN (
|
||||
SELECT s.id FROM servers s WHERE s.name = $1 AND server_extensions.server_id = s.id
|
||||
)
|
||||
AND is_latest = true
|
||||
`
|
||||
_, err = tx.Exec(ctx, updateQuery, serverDetail.Name)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to update existing latest version: %w", err)
|
||||
}
|
||||
}
|
||||
|
||||
// Insert new server record
|
||||
insertServerQuery := `
|
||||
INSERT INTO servers (id, name, description, status, repository, version, packages, remotes)
|
||||
VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
|
||||
`
|
||||
_, err = tx.Exec(ctx, insertServerQuery,
|
||||
serverID,
|
||||
serverDetail.Name,
|
||||
serverDetail.Description,
|
||||
serverDetail.Status,
|
||||
repositoryJSON,
|
||||
serverDetail.VersionDetail.Version,
|
||||
packagesJSON,
|
||||
remotesJSON,
|
||||
)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to insert server: %w", err)
|
||||
}
|
||||
|
||||
// Insert server extensions record
|
||||
insertExtensionsQuery := `
|
||||
INSERT INTO server_extensions (id, server_id, published_at, updated_at, is_latest, release_date, publisher_extensions)
|
||||
VALUES ($1, $2, $3, $4, $5, $6, $7)
|
||||
`
|
||||
_, err = tx.Exec(ctx, insertExtensionsQuery,
|
||||
registryID,
|
||||
serverID,
|
||||
now,
|
||||
now,
|
||||
true, // is_latest
|
||||
now, // release_date
|
||||
publisherExtensionsJSON,
|
||||
)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to insert server extensions: %w", err)
|
||||
}
|
||||
|
||||
// Commit transaction
|
||||
if err := tx.Commit(ctx); err != nil {
|
||||
return nil, fmt.Errorf("failed to commit transaction: %w", err)
|
||||
}
|
||||
|
||||
// Create and return the ServerRecord
|
||||
record := &model.ServerRecord{
|
||||
ServerJSON: serverDetail,
|
||||
RegistryMetadata: model.RegistryMetadata{
|
||||
ID: registryID,
|
||||
PublishedAt: now,
|
||||
UpdatedAt: now,
|
||||
IsLatest: true,
|
||||
ReleaseDate: now.Format(time.RFC3339),
|
||||
},
|
||||
PublisherExtensions: publisherExtensions,
|
||||
}
|
||||
|
||||
return record, nil
|
||||
}
|
||||
|
||||
// ImportSeed imports initial data from a seed file into PostgreSQL
|
||||
func (db *PostgreSQL) ImportSeed(ctx context.Context, seedFilePath string) error {
|
||||
// Read seed data using the shared ReadSeedFile function
|
||||
seedData, err := ReadSeedFile(ctx, seedFilePath)
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to read seed file: %w", err)
|
||||
}
|
||||
|
||||
// Start a transaction for batch import
|
||||
tx, err := db.conn.Begin(ctx)
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to start transaction: %w", err)
|
||||
}
|
||||
defer func() {
|
||||
if rollbackErr := tx.Rollback(ctx); rollbackErr != nil && !errors.Is(rollbackErr, pgx.ErrTxClosed) {
|
||||
log.Printf("Failed to rollback transaction: %v", rollbackErr)
|
||||
}
|
||||
}()
|
||||
|
||||
// Import each server
|
||||
for _, record := range seedData {
|
||||
// Convert record to the format expected by Publish
|
||||
serverDetail := record.ServerJSON
|
||||
publisherExtensions := record.PublisherExtensions
|
||||
|
||||
// Use the existing Publish logic but with specific ID from seed data
|
||||
if err := db.publishWithTransaction(ctx, tx, serverDetail, publisherExtensions, &record.RegistryMetadata); err != nil {
|
||||
return fmt.Errorf("failed to import server %s: %w", serverDetail.Name, err)
|
||||
}
|
||||
}
|
||||
|
||||
// Commit the transaction
|
||||
if err := tx.Commit(ctx); err != nil {
|
||||
return fmt.Errorf("failed to commit seed import transaction: %w", err)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// publishWithTransaction handles publishing within an existing transaction, optionally with predefined metadata
|
||||
func (db *PostgreSQL) publishWithTransaction(ctx context.Context, tx pgx.Tx, serverDetail model.ServerDetail, publisherExtensions map[string]interface{}, existingMetadata *model.RegistryMetadata) error {
|
||||
var serverID string
|
||||
var extensionID string
|
||||
|
||||
if existingMetadata != nil && existingMetadata.ID != "" {
|
||||
// Use predefined IDs from seed data
|
||||
serverID = existingMetadata.ID
|
||||
extensionID = existingMetadata.ID // In seed data, these are the same
|
||||
} else {
|
||||
// Generate new UUIDs for normal publishing
|
||||
serverID = uuid.New().String()
|
||||
extensionID = uuid.New().String()
|
||||
}
|
||||
|
||||
// Marshal packages and remotes to JSONB
|
||||
packagesJSON, err := json.Marshal(serverDetail.Packages)
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to marshal packages: %w", err)
|
||||
|
|
@ -258,143 +471,77 @@ func (db *PostgreSQL) Publish(ctx context.Context, serverDetail *model.ServerDet
|
|||
return fmt.Errorf("failed to marshal remotes: %w", err)
|
||||
}
|
||||
|
||||
// Generate ID and set metadata
|
||||
if serverDetail.ID == "" {
|
||||
serverDetail.ID = uuid.New().String()
|
||||
}
|
||||
serverDetail.VersionDetail.IsLatest = true
|
||||
if serverDetail.VersionDetail.ReleaseDate == "" {
|
||||
serverDetail.VersionDetail.ReleaseDate = time.Now().Format(time.RFC3339)
|
||||
}
|
||||
|
||||
releaseDate, err := time.Parse(time.RFC3339, serverDetail.VersionDetail.ReleaseDate)
|
||||
repositoryJSON, err := json.Marshal(serverDetail.Repository)
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to parse release date: %w", err)
|
||||
return fmt.Errorf("failed to marshal repository: %w", err)
|
||||
}
|
||||
|
||||
// Update existing latest version to not be latest
|
||||
if existingVersion != "" {
|
||||
updateQuery := `
|
||||
UPDATE servers
|
||||
SET is_latest = false
|
||||
WHERE name = $1 AND is_latest = true
|
||||
`
|
||||
_, err = tx.Exec(ctx, updateQuery, serverDetail.Name)
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to update existing latest version: %w", err)
|
||||
}
|
||||
publisherExtensionsJSON, err := json.Marshal(publisherExtensions)
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to marshal publisher extensions: %w", err)
|
||||
}
|
||||
|
||||
// Insert new server version
|
||||
insertQuery := `
|
||||
INSERT INTO servers (id, name, description, status, repository, version, release_date, is_latest, packages, remotes)
|
||||
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
|
||||
`
|
||||
_, err = tx.Exec(ctx, insertQuery,
|
||||
serverDetail.ID,
|
||||
// Insert or update server record
|
||||
serverQuery := `
|
||||
INSERT INTO servers (id, name, description, status, repository, version, packages, remotes, created_at, updated_at)
|
||||
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, NOW(), NOW())
|
||||
ON CONFLICT (name, version)
|
||||
DO UPDATE SET
|
||||
description = EXCLUDED.description,
|
||||
status = EXCLUDED.status,
|
||||
repository = EXCLUDED.repository,
|
||||
packages = EXCLUDED.packages,
|
||||
remotes = EXCLUDED.remotes,
|
||||
updated_at = NOW()
|
||||
RETURNING id`
|
||||
|
||||
var returnedServerID string
|
||||
err = tx.QueryRow(ctx, serverQuery,
|
||||
serverID,
|
||||
serverDetail.Name,
|
||||
serverDetail.Description,
|
||||
serverDetail.Status,
|
||||
string(serverDetail.Status),
|
||||
repositoryJSON,
|
||||
serverDetail.VersionDetail.Version,
|
||||
releaseDate,
|
||||
serverDetail.VersionDetail.IsLatest,
|
||||
packagesJSON,
|
||||
remotesJSON,
|
||||
).Scan(&returnedServerID)
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to insert/update server: %w", err)
|
||||
}
|
||||
|
||||
// Insert or update server extensions
|
||||
extensionQuery := `
|
||||
INSERT INTO server_extensions (id, server_id, published_at, updated_at, is_latest, release_date, publisher_extensions)
|
||||
VALUES ($1, $2, $3, NOW(), true, $4, $5)
|
||||
ON CONFLICT (server_id)
|
||||
DO UPDATE SET
|
||||
updated_at = NOW(),
|
||||
is_latest = true,
|
||||
release_date = EXCLUDED.release_date,
|
||||
publisher_extensions = EXCLUDED.publisher_extensions`
|
||||
|
||||
var publishedAt, releaseDate string
|
||||
if existingMetadata != nil {
|
||||
publishedAt = existingMetadata.PublishedAt.Format(time.RFC3339)
|
||||
releaseDate = existingMetadata.ReleaseDate
|
||||
} else {
|
||||
now := time.Now().Format(time.RFC3339)
|
||||
publishedAt = now
|
||||
releaseDate = now
|
||||
}
|
||||
|
||||
_, err = tx.Exec(ctx, extensionQuery,
|
||||
extensionID,
|
||||
returnedServerID,
|
||||
publishedAt,
|
||||
releaseDate,
|
||||
publisherExtensionsJSON,
|
||||
)
|
||||
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to insert server: %w", err)
|
||||
return fmt.Errorf("failed to insert/update server extensions: %w", err)
|
||||
}
|
||||
|
||||
return tx.Commit(ctx)
|
||||
}
|
||||
|
||||
// ImportSeed imports initial data from a seed file into PostgreSQL
|
||||
func (db *PostgreSQL) ImportSeed(ctx context.Context, seedFilePath string) error {
|
||||
servers, err := ReadSeedFile(ctx, seedFilePath)
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to read seed file: %w", err)
|
||||
}
|
||||
|
||||
log.Printf("Importing %d servers into PostgreSQL", len(servers))
|
||||
|
||||
for i, server := range servers {
|
||||
if server.ID == "" || server.Name == "" {
|
||||
log.Printf("Skipping server %d: ID or Name is empty", i+1)
|
||||
continue
|
||||
}
|
||||
|
||||
if server.VersionDetail.Version == "" {
|
||||
server.VersionDetail.Version = "0.0.1-seed"
|
||||
server.VersionDetail.ReleaseDate = time.Now().Format(time.RFC3339)
|
||||
server.VersionDetail.IsLatest = true
|
||||
}
|
||||
|
||||
// Prepare JSON data
|
||||
repositoryJSON, err := json.Marshal(server.Repository)
|
||||
if err != nil {
|
||||
log.Printf("Error marshaling repository for server %s: %v", server.ID, err)
|
||||
continue
|
||||
}
|
||||
|
||||
packagesJSON, err := json.Marshal(server.Packages)
|
||||
if err != nil {
|
||||
log.Printf("Error marshaling packages for server %s: %v", server.ID, err)
|
||||
continue
|
||||
}
|
||||
|
||||
remotesJSON, err := json.Marshal(server.Remotes)
|
||||
if err != nil {
|
||||
log.Printf("Error marshaling remotes for server %s: %v", server.ID, err)
|
||||
continue
|
||||
}
|
||||
|
||||
releaseDate, err := time.Parse(time.RFC3339, server.VersionDetail.ReleaseDate)
|
||||
if err != nil {
|
||||
log.Printf("Error parsing release date for server %s: %v", server.ID, err)
|
||||
releaseDate = time.Now()
|
||||
}
|
||||
|
||||
// Use UPSERT (INSERT ... ON CONFLICT DO UPDATE)
|
||||
upsertQuery := `
|
||||
INSERT INTO servers (id, name, description, status, repository, version, release_date, is_latest, packages, remotes)
|
||||
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
|
||||
ON CONFLICT (id) DO UPDATE SET
|
||||
name = EXCLUDED.name,
|
||||
description = EXCLUDED.description,
|
||||
status = EXCLUDED.status,
|
||||
repository = EXCLUDED.repository,
|
||||
version = EXCLUDED.version,
|
||||
release_date = EXCLUDED.release_date,
|
||||
is_latest = EXCLUDED.is_latest,
|
||||
packages = EXCLUDED.packages,
|
||||
remotes = EXCLUDED.remotes,
|
||||
updated_at = NOW()
|
||||
`
|
||||
|
||||
_, err = db.conn.Exec(ctx, upsertQuery,
|
||||
server.ID,
|
||||
server.Name,
|
||||
server.Description,
|
||||
server.Status,
|
||||
repositoryJSON,
|
||||
server.VersionDetail.Version,
|
||||
releaseDate,
|
||||
server.VersionDetail.IsLatest,
|
||||
packagesJSON,
|
||||
remotesJSON,
|
||||
)
|
||||
|
||||
if err != nil {
|
||||
log.Printf("Error importing server %s: %v", server.ID, err)
|
||||
continue
|
||||
}
|
||||
|
||||
log.Printf("[%d/%d] Imported server: %s", i+1, len(servers), server.Name)
|
||||
}
|
||||
|
||||
log.Println("PostgreSQL database import completed successfully")
|
||||
return nil
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue