package api import ( "context" "encoding/json" "fmt" "net/http" "strconv" "strings" "time" "droboticflow/internal/domain" "droboticflow/internal/store" "github.com/go-chi/chi/v5" "go.mongodb.org/mongo-driver/mongo" "go.mongodb.org/mongo-driver/mongo/options" ) type databaseBrowserTarget string const ( databaseBrowserTargetPlatform databaseBrowserTarget = "platform" databaseBrowserTargetBusiness databaseBrowserTarget = "business" ) type databaseBrowserStore interface { GetDatabaseOverview(context.Context) (domain.DatabaseOverview, error) QueryDatabaseCollection(context.Context, domain.DatabaseQueryInput) (domain.DatabaseQueryResult, error) CreateDatabaseCollection(context.Context, string) (domain.DatabaseCollectionSummary, error) RenameDatabaseCollection(context.Context, string, string) (domain.DatabaseCollectionSummary, error) DeleteDatabaseCollection(context.Context, string) error ListDatabaseIndexes(context.Context, string) ([]domain.DatabaseIndexSummary, error) CreateDatabaseIndex(context.Context, string, domain.DatabaseIndexCreateInput) (domain.DatabaseIndexSummary, error) DeleteDatabaseIndex(context.Context, string, string) error InsertDatabaseDocument(context.Context, string, map[string]any) (map[string]any, error) ReplaceDatabaseDocument(context.Context, string, string, map[string]any) (map[string]any, error) PatchDatabaseDocument(context.Context, string, string, map[string]any) (map[string]any, error) UpsertDatabaseDocument(context.Context, string, map[string]any, map[string]any, map[string]any) (map[string]any, bool, error) DeleteDatabaseDocument(context.Context, string, string) error } var mongoConnectionStoreResolver = func(ctx context.Context, connection *domain.MongoConnectionRecord) (databaseBrowserStore, func(), error) { if connection == nil { return nil, nil, nil } client, err := mongo.Connect(ctx, options.Client().ApplyURI(strings.TrimSpace(connection.URI))) if err != nil { return nil, nil, err } cleanup := func() { disconnectCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() _ = client.Disconnect(disconnectCtx) } if err := client.Ping(ctx, nil); err != nil { cleanup() return nil, nil, err } return store.NewMongoStore(client.Database(strings.TrimSpace(connection.Database))), cleanup, nil } func parseDatabaseQueryFilter(raw string) (map[string]any, error) { trimmed := strings.TrimSpace(raw) if trimmed == "" { return map[string]any{}, nil } filter := map[string]any{} if err := json.Unmarshal([]byte(trimmed), &filter); err != nil { return nil, err } return filter, nil } func validateDatabaseQueryFilter(field string, value map[string]any) []validationIssue { return validateDatabaseQueryFilterValue(field, value) } func validateDatabaseQueryFilterValue(field string, value any) []validationIssue { issues := make([]validationIssue, 0) switch typed := value.(type) { case map[string]any: for key, item := range typed { trimmedKey := strings.TrimSpace(key) itemField := field if trimmedKey != "" { itemField = field + "." + trimmedKey } if trimmedKey == "" { issues = append(issues, validationIssue{Field: field, Message: field + " cannot contain empty field names"}) continue } if strings.ContainsRune(trimmedKey, '\x00') { issues = append(issues, validationIssue{Field: itemField, Message: field + " cannot contain NUL bytes"}) continue } if trimmedKey == "$where" { issues = append(issues, validationIssue{Field: itemField, Message: field + " cannot use the $where operator"}) continue } if !strings.HasPrefix(trimmedKey, "$") && (strings.HasPrefix(trimmedKey, ".") || strings.HasSuffix(trimmedKey, ".") || strings.Contains(trimmedKey, "..")) { issues = append(issues, validationIssue{Field: itemField, Message: field + " cannot contain empty path segments"}) continue } issues = append(issues, validateDatabaseQueryFilterValue(itemField, item)...) } case []any: for index, item := range typed { issues = append(issues, validateDatabaseQueryFilterValue(fmt.Sprintf("%s[%d]", field, index), item)...) } } return issues } func parseDatabaseBrowserPageQuery(value string, field string, fallback int, min int, max int) (int, *validationIssue) { trimmed := strings.TrimSpace(value) if trimmed == "" { return fallback, nil } parsed, err := strconv.Atoi(trimmed) if err != nil { return 0, &validationIssue{Field: field, Message: field + " must be an integer"} } if parsed < min && min == 0 { return 0, &validationIssue{Field: field, Message: field + " must be zero or greater"} } if parsed < min { return 0, &validationIssue{Field: field, Message: fmt.Sprintf("%s must be greater than or equal to %d", field, min)} } if max > 0 && parsed > max { return max, nil } return parsed, nil } func normalizeDatabaseBrowserTarget(raw string) databaseBrowserTarget { switch strings.ToLower(strings.TrimSpace(raw)) { case string(databaseBrowserTargetPlatform): return databaseBrowserTargetPlatform case string(databaseBrowserTargetBusiness): return databaseBrowserTargetBusiness default: return databaseBrowserTargetBusiness } } func validateDatabaseCollectionName(field string, value string) *validationIssue { name := strings.TrimSpace(value) if store.IsPrivateDerivedCollection(name) { return &validationIssue{Field: field, Message: "internal statistics collection is not accessible"} } label := "collection name" if field == "newName" { label = "new collection name" } if name == "" { return &validationIssue{Field: field, Message: label + " is required"} } if name == "." || name == ".." { return &validationIssue{Field: field, Message: label + " is invalid"} } if strings.ContainsRune(name, '\x00') { return &validationIssue{Field: field, Message: label + " cannot contain NUL bytes"} } if strings.ContainsAny(name, `/\`) { return &validationIssue{Field: field, Message: label + " cannot contain path separators"} } if strings.Contains(name, "$") { return &validationIssue{Field: field, Message: label + " cannot contain $"} } if strings.HasPrefix(strings.ToLower(name), "system.") { return &validationIssue{Field: field, Message: label + " cannot use the reserved system prefix"} } return nil } func validateDatabaseIndexName(field string, value string, required bool) *validationIssue { name := strings.TrimSpace(value) if name == "" { if required { return &validationIssue{Field: field, Message: "index name is required"} } return nil } if name == "_id_" { return &validationIssue{Field: field, Message: "index name _id_ is reserved"} } if strings.ContainsRune(name, '\x00') { return &validationIssue{Field: field, Message: "index name cannot contain NUL bytes"} } if strings.ContainsAny(name, `/\`) { return &validationIssue{Field: field, Message: "index name cannot contain path separators"} } if strings.Contains(name, "$") { return &validationIssue{Field: field, Message: "index name cannot contain $"} } return nil } func validateDatabaseIndexKeyDirection(field string, value any) *validationIssue { normalized := strings.ToLower(strings.TrimSpace(fmt.Sprint(value))) switch normalized { case "1", "1.0", "-1", "-1.0", "text", "hashed", "2d", "2dsphere": return nil default: return &validationIssue{Field: field, Message: "index key direction must be 1, -1, text, hashed, 2d, or 2dsphere"} } } func validateDatabaseIndexKeys(field string, keys map[string]any) []validationIssue { if len(keys) == 0 { return []validationIssue{{Field: field, Message: "index keys are required"}} } issues := make([]validationIssue, 0) for key, value := range keys { trimmedKey := strings.TrimSpace(key) itemField := field if trimmedKey != "" { itemField = field + "." + trimmedKey } if trimmedKey == "" { issues = append(issues, validationIssue{Field: field, Message: "index keys cannot contain empty field names"}) continue } if strings.ContainsRune(trimmedKey, '\x00') { issues = append(issues, validationIssue{Field: itemField, Message: "index keys cannot contain NUL bytes"}) continue } if strings.HasPrefix(trimmedKey, "$") { issues = append(issues, validationIssue{Field: itemField, Message: "index keys cannot contain Mongo operator keys"}) continue } if strings.HasPrefix(trimmedKey, ".") || strings.HasSuffix(trimmedKey, ".") || strings.Contains(trimmedKey, "..") { issues = append(issues, validationIssue{Field: itemField, Message: "index keys cannot contain empty path segments"}) continue } if issue := validateDatabaseIndexKeyDirection(itemField, value); issue != nil { issues = append(issues, *issue) } } return issues } func validateDatabaseDocumentMutationInput(field string, document map[string]any) []validationIssue { return validateExternalBusinessWriteObject(field, document, true) } func mongoConnectionConfigured(connection *domain.MongoConnectionRecord) bool { if connection == nil { return false } return strings.TrimSpace(connection.URI) != "" && strings.TrimSpace(connection.Database) != "" } func (server *server) databaseBrowserOverview(ctx context.Context, target databaseBrowserTarget, connectionID string) (domain.DatabaseOverview, error) { item, err := server.store.GetDatabaseOverview(ctx) if target == databaseBrowserTargetPlatform { if err != nil { return domain.DatabaseOverview{}, err } item.Target = string(databaseBrowserTargetPlatform) item.Configured = true return item, nil } connection, err := server.getMongoConnection(ctx, connectionID) if err != nil && strings.TrimSpace(connectionID) != "" { return domain.DatabaseOverview{}, err } overview := domain.DatabaseOverview{ Target: string(databaseBrowserTargetBusiness), ConnectionID: strings.TrimSpace(connectionID), ConnectionName: "", Provider: "mongodb", Database: "", ReadOnly: true, Configured: mongoConnectionConfigured(connection), Collections: []domain.DatabaseCollectionSummary{}, } if connection == nil || !overview.Configured { return overview, nil } overview.ConnectionID = connection.ID overview.ConnectionName = connection.Name overview.Database = strings.TrimSpace(connection.Database) browserStore, cleanup, err := mongoConnectionStoreResolver(ctx, connection) if err != nil { return domain.DatabaseOverview{}, err } defer cleanup() item, err = browserStore.GetDatabaseOverview(ctx) if err != nil { return domain.DatabaseOverview{}, err } item.Target = string(databaseBrowserTargetBusiness) item.ConnectionID = connection.ID item.ConnectionName = connection.Name item.Configured = true item.ReadOnly = false return item, nil } func (server *server) databaseBrowserQuery(ctx context.Context, target databaseBrowserTarget, connectionID string, input domain.DatabaseQueryInput) (domain.DatabaseQueryResult, error) { if target == databaseBrowserTargetPlatform { item, err := server.store.QueryDatabaseCollection(ctx, input) if err != nil { return domain.DatabaseQueryResult{}, err } item.Target = string(databaseBrowserTargetPlatform) item.Configured = true return item, nil } connection, err := server.getMongoConnection(ctx, connectionID) if err != nil && strings.TrimSpace(connectionID) != "" { return domain.DatabaseQueryResult{}, err } if connection == nil || !mongoConnectionConfigured(connection) { return domain.DatabaseQueryResult{ Target: string(databaseBrowserTargetBusiness), ConnectionID: strings.TrimSpace(connectionID), Provider: "mongodb", Database: "", Collection: input.Collection, Limit: input.Limit, Skip: input.Skip, Configured: false, Documents: []map[string]any{}, }, nil } browserStore, cleanup, err := mongoConnectionStoreResolver(ctx, connection) if err != nil { return domain.DatabaseQueryResult{}, err } defer cleanup() item, err := browserStore.QueryDatabaseCollection(ctx, input) if err != nil { return domain.DatabaseQueryResult{}, err } item.Target = string(databaseBrowserTargetBusiness) item.ConnectionID = connection.ID item.ConnectionName = connection.Name item.Configured = true return item, nil } func (server *server) resolveBusinessDatabaseStore(ctx context.Context, connectionID string) (databaseBrowserStore, *domain.MongoConnectionRecord, func(), error) { connection, err := server.getMongoConnection(ctx, connectionID) if err != nil && strings.TrimSpace(connectionID) != "" { return nil, nil, nil, err } if connection == nil || !mongoConnectionConfigured(connection) { return nil, connection, nil, fmt.Errorf("mongo connection is not configured") } browserStore, cleanup, err := mongoConnectionStoreResolver(ctx, connection) if err != nil { return nil, connection, nil, err } return browserStore, connection, cleanup, nil } func decodeDatabaseCollectionCreateInput(request *http.Request) (domain.DatabaseCollectionCreateInput, error) { input := domain.DatabaseCollectionCreateInput{} if err := json.NewDecoder(request.Body).Decode(&input); err != nil { return domain.DatabaseCollectionCreateInput{}, err } return input, nil } func decodeDatabaseCollectionRenameInput(request *http.Request) (domain.DatabaseCollectionRenameInput, error) { input := domain.DatabaseCollectionRenameInput{} if err := json.NewDecoder(request.Body).Decode(&input); err != nil { return domain.DatabaseCollectionRenameInput{}, err } return input, nil } func decodeDatabaseDocumentMutationInput(request *http.Request) (domain.DatabaseDocumentMutationInput, error) { input := domain.DatabaseDocumentMutationInput{} if err := json.NewDecoder(request.Body).Decode(&input); err != nil { return domain.DatabaseDocumentMutationInput{}, err } if input.Document == nil { input.Document = map[string]any{} } return input, nil } func decodeMongoConnectionTestInput(request *http.Request) (domain.MongoConnectionTestInput, error) { input := domain.MongoConnectionTestInput{} if err := json.NewDecoder(request.Body).Decode(&input); err != nil { return domain.MongoConnectionTestInput{}, err } return input, nil } func databaseBrowserNotFound(err error) bool { return strings.Contains(strings.ToLower(err.Error()), "not found") } func renderDatabaseBrowserWriteError(writer http.ResponseWriter, err error) { if databaseBrowserNotFound(err) { renderJSON(writer, http.StatusNotFound, map[string]string{"error": err.Error()}) return } if mongo.IsDuplicateKeyError(err) { renderValidationError(writer, validationIssue{Field: "document", Message: "database unique constraint rejected duplicate value"}) return } renderError(writer, http.StatusInternalServerError, err) } func (server *server) handleMongoConnectionsTest(writer http.ResponseWriter, request *http.Request) { input, err := decodeMongoConnectionTestInput(request) if err != nil { renderValidationError(writer, validationIssue{Field: "body", Message: "request body must be valid JSON"}) return } var connection *domain.MongoConnectionRecord connectionID := strings.TrimSpace(input.ID) if connectionID != "" { connection, err = server.getMongoConnection(request.Context(), connectionID) if err != nil { renderValidationError(writer, validationIssue{Field: "id", Message: err.Error()}) return } } else { uri := strings.TrimSpace(input.URI) database := strings.TrimSpace(input.Database) if uri == "" { renderValidationError(writer, validationIssue{Field: "uri", Message: "uri is required"}) return } if issue := validateMongoConnectionURI("uri", uri); issue != nil { renderValidationError(writer, *issue) return } if database == "" { renderValidationError(writer, validationIssue{Field: "database", Message: "database is required"}) return } connection = &domain.MongoConnectionRecord{ ID: "", Name: "probe", URI: uri, Database: database, } } browserStore, cleanup, err := mongoConnectionStoreResolver(request.Context(), connection) if err != nil { renderError(writer, http.StatusBadGateway, err) return } defer cleanup() item, err := browserStore.GetDatabaseOverview(request.Context()) if err != nil { renderError(writer, http.StatusBadGateway, err) return } item.Target = string(databaseBrowserTargetBusiness) item.Configured = true item.ReadOnly = false if connection != nil { item.ConnectionID = connection.ID item.ConnectionName = connection.Name item.Database = strings.TrimSpace(connection.Database) } renderJSON(writer, http.StatusOK, item) } func (server *server) handleDatabaseOverview(writer http.ResponseWriter, request *http.Request) { item, err := server.databaseBrowserOverview( request.Context(), normalizeDatabaseBrowserTarget(request.URL.Query().Get("target")), request.URL.Query().Get("connectionId"), ) if err != nil { renderError(writer, http.StatusInternalServerError, err) return } renderJSON(writer, http.StatusOK, item) } func (server *server) handleDatabaseCollectionCreate(writer http.ResponseWriter, request *http.Request) { input, err := decodeDatabaseCollectionCreateInput(request) if err != nil { renderValidationError(writer, validationIssue{Field: "body", Message: "request body must be valid JSON"}) return } name := strings.TrimSpace(input.Name) if issue := validateDatabaseCollectionName("name", name); issue != nil { renderValidationError(writer, *issue) return } browserStore, _, cleanup, err := server.resolveBusinessDatabaseStore(request.Context(), request.URL.Query().Get("connectionId")) if err != nil { renderValidationError(writer, validationIssue{Field: "connectionId", Message: err.Error()}) return } defer cleanup() summary, err := browserStore.CreateDatabaseCollection(request.Context(), name) if err != nil { renderDatabaseBrowserWriteError(writer, err) return } renderJSON(writer, http.StatusCreated, domain.DatabaseCollectionMutationResult{ Collection: summary.Name, Summary: summary, }) } func (server *server) handleDatabaseCollectionRename(writer http.ResponseWriter, request *http.Request) { input, err := decodeDatabaseCollectionRenameInput(request) if err != nil { renderValidationError(writer, validationIssue{Field: "body", Message: "request body must be valid JSON"}) return } currentName := strings.TrimSpace(chi.URLParam(request, "name")) newName := strings.TrimSpace(input.NewName) issues := make([]validationIssue, 0, 2) if issue := validateDatabaseCollectionName("name", currentName); issue != nil { issues = append(issues, *issue) } if issue := validateDatabaseCollectionName("newName", newName); issue != nil { issues = append(issues, *issue) } if len(issues) > 0 { renderValidationError(writer, issues...) return } browserStore, _, cleanup, err := server.resolveBusinessDatabaseStore(request.Context(), request.URL.Query().Get("connectionId")) if err != nil { renderValidationError(writer, validationIssue{Field: "connectionId", Message: err.Error()}) return } defer cleanup() summary, err := browserStore.RenameDatabaseCollection(request.Context(), currentName, newName) if err != nil { renderDatabaseBrowserWriteError(writer, err) return } renderJSON(writer, http.StatusOK, domain.DatabaseCollectionMutationResult{ Collection: summary.Name, Summary: summary, }) } func (server *server) handleDatabaseCollectionDelete(writer http.ResponseWriter, request *http.Request) { name := strings.TrimSpace(chi.URLParam(request, "name")) if issue := validateDatabaseCollectionName("name", name); issue != nil { renderValidationError(writer, *issue) return } browserStore, _, cleanup, err := server.resolveBusinessDatabaseStore(request.Context(), request.URL.Query().Get("connectionId")) if err != nil { renderValidationError(writer, validationIssue{Field: "connectionId", Message: err.Error()}) return } defer cleanup() if err := browserStore.DeleteDatabaseCollection(request.Context(), name); err != nil { renderDatabaseBrowserWriteError(writer, err) return } renderJSON(writer, http.StatusOK, domain.DatabaseCollectionDeleteResult{ Collection: name, Deleted: true, }) } func (server *server) handleDatabaseCollectionIndexes(writer http.ResponseWriter, request *http.Request) { collectionName := strings.TrimSpace(chi.URLParam(request, "name")) if issue := validateDatabaseCollectionName("name", collectionName); issue != nil { renderValidationError(writer, *issue) return } browserStore, _, cleanup, err := server.resolveBusinessDatabaseStore(request.Context(), request.URL.Query().Get("connectionId")) if err != nil { renderValidationError(writer, validationIssue{Field: "connectionId", Message: err.Error()}) return } defer cleanup() indexes, err := browserStore.ListDatabaseIndexes(request.Context(), collectionName) if err != nil { renderDatabaseBrowserWriteError(writer, err) return } renderJSON(writer, http.StatusOK, domain.DatabaseIndexesResult{ Collection: collectionName, Indexes: indexes, }) } func (server *server) handleDatabaseCollectionIndexCreate(writer http.ResponseWriter, request *http.Request) { input := domain.DatabaseIndexCreateInput{} if !decodeJSON(writer, request, &input) { return } collectionName := strings.TrimSpace(chi.URLParam(request, "name")) issues := make([]validationIssue, 0) if issue := validateDatabaseCollectionName("name", collectionName); issue != nil { issues = append(issues, *issue) } if issue := validateDatabaseIndexName("name", input.Name, false); issue != nil { issues = append(issues, *issue) } issues = append(issues, validateDatabaseIndexKeys("keys", input.Keys)...) if len(issues) > 0 { renderValidationError(writer, issues...) return } input.Name = strings.TrimSpace(input.Name) browserStore, _, cleanup, err := server.resolveBusinessDatabaseStore(request.Context(), request.URL.Query().Get("connectionId")) if err != nil { renderValidationError(writer, validationIssue{Field: "connectionId", Message: err.Error()}) return } defer cleanup() indexSummary, err := browserStore.CreateDatabaseIndex(request.Context(), collectionName, input) if err != nil { renderDatabaseBrowserWriteError(writer, err) return } renderJSON(writer, http.StatusCreated, domain.DatabaseIndexMutationResult{ Collection: collectionName, Index: indexSummary, }) } func (server *server) handleDatabaseCollectionIndexDelete(writer http.ResponseWriter, request *http.Request) { collectionName := strings.TrimSpace(chi.URLParam(request, "name")) indexName := strings.TrimSpace(chi.URLParam(request, "indexName")) issues := make([]validationIssue, 0, 2) if issue := validateDatabaseCollectionName("name", collectionName); issue != nil { issues = append(issues, *issue) } if issue := validateDatabaseIndexName("indexName", indexName, true); issue != nil { issues = append(issues, *issue) } if len(issues) > 0 { renderValidationError(writer, issues...) return } browserStore, _, cleanup, err := server.resolveBusinessDatabaseStore(request.Context(), request.URL.Query().Get("connectionId")) if err != nil { renderValidationError(writer, validationIssue{Field: "connectionId", Message: err.Error()}) return } defer cleanup() if err := browserStore.DeleteDatabaseIndex(request.Context(), collectionName, indexName); err != nil { renderDatabaseBrowserWriteError(writer, err) return } renderJSON(writer, http.StatusOK, domain.DatabaseIndexDeleteResult{ Collection: collectionName, IndexName: indexName, Deleted: true, }) } func (server *server) handleDatabaseCollectionDocuments(writer http.ResponseWriter, request *http.Request) { target := normalizeDatabaseBrowserTarget(request.URL.Query().Get("target")) filter, err := parseDatabaseQueryFilter(request.URL.Query().Get("filter")) if err != nil { renderValidationError(writer, validationIssue{Field: "filter", Message: "filter must be valid JSON object"}) return } limit, limitIssue := parseDatabaseBrowserPageQuery(request.URL.Query().Get("limit"), "limit", 50, 1, 200) skip, skipIssue := parseDatabaseBrowserPageQuery(request.URL.Query().Get("skip"), "skip", 0, 0, 5000) issues := make([]validationIssue, 0, 2) if limitIssue != nil { issues = append(issues, *limitIssue) } if skipIssue != nil { issues = append(issues, *skipIssue) } collectionName := strings.TrimSpace(chi.URLParam(request, "name")) if issue := validateDatabaseCollectionName("name", collectionName); issue != nil { issues = append(issues, *issue) } issues = append(issues, validateDatabaseQueryFilter("filter", filter)...) if len(issues) > 0 { renderValidationError(writer, issues...) return } input := domain.DatabaseQueryInput{ Collection: collectionName, Filter: filter, Limit: limit, Skip: skip, } item, err := server.databaseBrowserQuery(request.Context(), target, request.URL.Query().Get("connectionId"), input) if err != nil { if strings.Contains(strings.ToLower(err.Error()), "not found") { renderJSON(writer, http.StatusNotFound, map[string]string{"error": err.Error()}) return } renderError(writer, http.StatusInternalServerError, err) return } if target == databaseBrowserTargetBusiness && !item.Configured { renderValidationError(writer, validationIssue{Field: "connectionId", Message: "mongo connection is not configured"}) return } renderJSON(writer, http.StatusOK, item) } func (server *server) handleDatabaseDocumentCreate(writer http.ResponseWriter, request *http.Request) { input, err := decodeDatabaseDocumentMutationInput(request) if err != nil { renderValidationError(writer, validationIssue{Field: "body", Message: "request body must be valid JSON"}) return } collectionName := strings.TrimSpace(chi.URLParam(request, "name")) issues := make([]validationIssue, 0) if issue := validateDatabaseCollectionName("name", collectionName); issue != nil { issues = append(issues, *issue) } issues = append(issues, validateDatabaseDocumentMutationInput("document", input.Document)...) if len(issues) > 0 { renderValidationError(writer, issues...) return } browserStore, _, cleanup, err := server.resolveBusinessDatabaseStore(request.Context(), request.URL.Query().Get("connectionId")) if err != nil { renderValidationError(writer, validationIssue{Field: "connectionId", Message: err.Error()}) return } defer cleanup() document, err := browserStore.InsertDatabaseDocument(request.Context(), collectionName, input.Document) if err != nil { renderDatabaseBrowserWriteError(writer, err) return } renderJSON(writer, http.StatusCreated, domain.DatabaseDocumentMutationResult{ Collection: collectionName, Document: document, }) } func (server *server) handleDatabaseDocumentReplace(writer http.ResponseWriter, request *http.Request) { input, err := decodeDatabaseDocumentMutationInput(request) if err != nil { renderValidationError(writer, validationIssue{Field: "body", Message: "request body must be valid JSON"}) return } collectionName := strings.TrimSpace(chi.URLParam(request, "name")) documentID := strings.TrimSpace(chi.URLParam(request, "documentId")) issues := make([]validationIssue, 0) if issue := validateDatabaseCollectionName("name", collectionName); issue != nil { issues = append(issues, *issue) } if documentID == "" { issues = append(issues, validationIssue{Field: "documentId", Message: "document id is required"}) } issues = append(issues, validateDatabaseDocumentMutationInput("document", input.Document)...) if len(issues) > 0 { renderValidationError(writer, issues...) return } browserStore, _, cleanup, err := server.resolveBusinessDatabaseStore(request.Context(), request.URL.Query().Get("connectionId")) if err != nil { renderValidationError(writer, validationIssue{Field: "connectionId", Message: err.Error()}) return } defer cleanup() document, err := browserStore.ReplaceDatabaseDocument( request.Context(), collectionName, documentID, input.Document, ) if err != nil { renderDatabaseBrowserWriteError(writer, err) return } renderJSON(writer, http.StatusOK, domain.DatabaseDocumentMutationResult{ Collection: collectionName, Document: document, }) } func (server *server) handleDatabaseDocumentDelete(writer http.ResponseWriter, request *http.Request) { collectionName := strings.TrimSpace(chi.URLParam(request, "name")) documentID := strings.TrimSpace(chi.URLParam(request, "documentId")) issues := make([]validationIssue, 0, 2) if issue := validateDatabaseCollectionName("name", collectionName); issue != nil { issues = append(issues, *issue) } if documentID == "" { issues = append(issues, validationIssue{Field: "documentId", Message: "document id is required"}) } if len(issues) > 0 { renderValidationError(writer, issues...) return } browserStore, _, cleanup, err := server.resolveBusinessDatabaseStore(request.Context(), request.URL.Query().Get("connectionId")) if err != nil { renderValidationError(writer, validationIssue{Field: "connectionId", Message: err.Error()}) return } defer cleanup() if err := browserStore.DeleteDatabaseDocument( request.Context(), collectionName, documentID, ); err != nil { renderDatabaseBrowserWriteError(writer, err) return } renderJSON(writer, http.StatusOK, domain.DatabaseDocumentDeleteResult{ Collection: collectionName, DocumentID: documentID, Deleted: true, }) }