droboticflow/internal/api/database_browser.go
2026-06-17 05:53:39 +08:00

596 lines
21 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 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 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
}
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) {
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()
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 name == "" {
renderValidationError(writer, validationIssue{Field: "name", Message: "collection name is required"})
return
}
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) {
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()
input, err := decodeDatabaseCollectionRenameInput(request)
if err != nil {
renderValidationError(writer, validationIssue{Field: "body", Message: "request body must be valid JSON"})
return
}
newName := strings.TrimSpace(input.NewName)
if newName == "" {
renderValidationError(writer, validationIssue{Field: "newName", Message: "new collection name is required"})
return
}
summary, err := browserStore.RenameDatabaseCollection(request.Context(), chi.URLParam(request, "name"), 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) {
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()
name := chi.URLParam(request, "name")
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) {
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(), chi.URLParam(request, "name"))
if err != nil {
renderDatabaseBrowserWriteError(writer, err)
return
}
renderJSON(writer, http.StatusOK, domain.DatabaseIndexesResult{
Collection: chi.URLParam(request, "name"),
Indexes: indexes,
})
}
func (server *server) handleDatabaseCollectionIndexCreate(writer http.ResponseWriter, request *http.Request) {
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()
input := domain.DatabaseIndexCreateInput{}
if !decodeJSON(writer, request, &input) {
return
}
if len(input.Keys) == 0 {
renderValidationError(writer, validationIssue{Field: "keys", Message: "index keys are required"})
return
}
indexSummary, err := browserStore.CreateDatabaseIndex(request.Context(), chi.URLParam(request, "name"), input)
if err != nil {
renderDatabaseBrowserWriteError(writer, err)
return
}
renderJSON(writer, http.StatusCreated, domain.DatabaseIndexMutationResult{
Collection: chi.URLParam(request, "name"),
Index: indexSummary,
})
}
func (server *server) handleDatabaseCollectionIndexDelete(writer http.ResponseWriter, request *http.Request) {
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()
indexName := chi.URLParam(request, "indexName")
if err := browserStore.DeleteDatabaseIndex(request.Context(), chi.URLParam(request, "name"), indexName); err != nil {
renderDatabaseBrowserWriteError(writer, err)
return
}
renderJSON(writer, http.StatusOK, domain.DatabaseIndexDeleteResult{
Collection: chi.URLParam(request, "name"),
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)
}
if len(issues) > 0 {
renderValidationError(writer, issues...)
return
}
input := domain.DatabaseQueryInput{
Collection: chi.URLParam(request, "name"),
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) {
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()
input, err := decodeDatabaseDocumentMutationInput(request)
if err != nil {
renderValidationError(writer, validationIssue{Field: "body", Message: "request body must be valid JSON"})
return
}
if len(input.Document) == 0 {
renderValidationError(writer, validationIssue{Field: "document", Message: "document is required"})
return
}
document, err := browserStore.InsertDatabaseDocument(request.Context(), chi.URLParam(request, "name"), input.Document)
if err != nil {
renderDatabaseBrowserWriteError(writer, err)
return
}
renderJSON(writer, http.StatusCreated, domain.DatabaseDocumentMutationResult{
Collection: chi.URLParam(request, "name"),
Document: document,
})
}
func (server *server) handleDatabaseDocumentReplace(writer http.ResponseWriter, request *http.Request) {
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()
input, err := decodeDatabaseDocumentMutationInput(request)
if err != nil {
renderValidationError(writer, validationIssue{Field: "body", Message: "request body must be valid JSON"})
return
}
if len(input.Document) == 0 {
renderValidationError(writer, validationIssue{Field: "document", Message: "document is required"})
return
}
document, err := browserStore.ReplaceDatabaseDocument(
request.Context(),
chi.URLParam(request, "name"),
chi.URLParam(request, "documentId"),
input.Document,
)
if err != nil {
renderDatabaseBrowserWriteError(writer, err)
return
}
renderJSON(writer, http.StatusOK, domain.DatabaseDocumentMutationResult{
Collection: chi.URLParam(request, "name"),
Document: document,
})
}
func (server *server) handleDatabaseDocumentDelete(writer http.ResponseWriter, request *http.Request) {
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(),
chi.URLParam(request, "name"),
chi.URLParam(request, "documentId"),
); err != nil {
renderDatabaseBrowserWriteError(writer, err)
return
}
renderJSON(writer, http.StatusOK, domain.DatabaseDocumentDeleteResult{
Collection: chi.URLParam(request, "name"),
DocumentID: chi.URLParam(request, "documentId"),
Deleted: true,
})
}