forked from longtao.wu/droboticflow
812 lines
29 KiB
Go
812 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)
|
|
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 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,
|
|
})
|
|
}
|