forked from longtao.wu/droboticflow
Include the accumulated workflow scheduling, run history, subtree rerun, operator UI, deployment, data asset, object storage, database browser, and documentation changes currently in the worktree.
577 lines
20 KiB
Go
577 lines
20 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 parsePositiveIntQuery(value string, fallback int, max int) int {
|
|
trimmed := strings.TrimSpace(value)
|
|
if trimmed == "" {
|
|
return fallback
|
|
}
|
|
parsed, err := strconv.Atoi(trimmed)
|
|
if err != nil || parsed < 0 {
|
|
return fallback
|
|
}
|
|
if max > 0 && parsed > max {
|
|
return max
|
|
}
|
|
return parsed
|
|
}
|
|
|
|
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
|
|
}
|
|
input := domain.DatabaseQueryInput{
|
|
Collection: chi.URLParam(request, "name"),
|
|
Filter: filter,
|
|
Limit: parsePositiveIntQuery(request.URL.Query().Get("limit"), 50, 200),
|
|
Skip: parsePositiveIntQuery(request.URL.Query().Get("skip"), 0, 5000),
|
|
}
|
|
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,
|
|
})
|
|
}
|