droboticflow/internal/api/database_browser.go

819 lines
29 KiB
Go

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,
})
}