droboticflow/internal/api/database_external_write.go
eust-w 43326d6a5e feat(platform): land workflow, data tooling, and docs updates
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.
2026-04-24 12:29:46 +08:00

632 lines
22 KiB
Go

package api
import (
"context"
"crypto/rand"
"crypto/sha256"
"crypto/subtle"
"encoding/hex"
"fmt"
"net/http"
"sort"
"strings"
"droboticflow/internal/domain"
"github.com/go-chi/chi/v5"
)
type externalBusinessWriteTokenCreateRequest struct {
Name string `json:"name"`
Description string `json:"description,omitempty"`
Enabled *bool `json:"enabled"`
Scopes []domain.ExternalBusinessWriteScope `json:"scopes"`
}
type externalBusinessWriteTokenUpdateRequest struct {
Name *string `json:"name"`
Description *string `json:"description"`
Enabled *bool `json:"enabled"`
Scopes *[]domain.ExternalBusinessWriteScope `json:"scopes"`
}
type externalBusinessWriteCreateRequest struct {
ConnectionID string `json:"connectionId"`
Collection string `json:"collection"`
Document map[string]any `json:"document"`
}
type externalBusinessWritePatchRequest struct {
ConnectionID string `json:"connectionId"`
Collection string `json:"collection"`
Patch map[string]any `json:"patch"`
}
type externalBusinessWriteUpsertRequest struct {
ConnectionID string `json:"connectionId"`
Collection string `json:"collection"`
Match map[string]any `json:"match"`
Patch map[string]any `json:"patch"`
SetOnInsert map[string]any `json:"setOnInsert,omitempty"`
}
type externalBusinessWriteTokenMutationResult struct {
Token domain.ExternalBusinessWriteTokenRecord `json:"token"`
APIKey string `json:"apiKey,omitempty"`
}
type externalBusinessWriteTokenRevealResult struct {
TokenID string `json:"tokenId"`
APIKey string `json:"apiKey"`
}
type externalBusinessWriteTokensResult struct {
Items []domain.ExternalBusinessWriteTokenRecord `json:"items"`
}
type externalBusinessWriteDocumentResult struct {
ConnectionID string `json:"connectionId"`
Collection string `json:"collection"`
Operation string `json:"operation"`
Document map[string]any `json:"document"`
}
type externalBusinessWriteTokenContextKey struct{}
func externalBusinessWriteAPIKeyHash(value string) string {
sum := sha256.Sum256([]byte(strings.TrimSpace(value)))
return hex.EncodeToString(sum[:])
}
func generateExternalBusinessWriteAPIKey() (string, string, string, error) {
randomBytes := make([]byte, 24)
if _, err := rand.Read(randomBytes); err != nil {
return "", "", "", err
}
apiKey := "dbw_" + hex.EncodeToString(randomBytes)
return apiKey, externalBusinessWriteAPIKeyHash(apiKey), maskedSecretPreview(apiKey), nil
}
func sanitizeExternalBusinessWriteToken(item domain.ExternalBusinessWriteTokenRecord) domain.ExternalBusinessWriteTokenRecord {
sanitized := item
sanitized.TokenValue = ""
sanitized.TokenHash = ""
if sanitized.Scopes == nil {
sanitized.Scopes = []domain.ExternalBusinessWriteScope{}
}
return sanitized
}
func sanitizeExternalBusinessWriteTokens(items []domain.ExternalBusinessWriteTokenRecord) []domain.ExternalBusinessWriteTokenRecord {
sanitized := make([]domain.ExternalBusinessWriteTokenRecord, 0, len(items))
for _, item := range items {
sanitized = append(sanitized, sanitizeExternalBusinessWriteToken(item))
}
sort.Slice(sanitized, func(left int, right int) bool {
return sanitized[left].CreatedAt > sanitized[right].CreatedAt
})
return sanitized
}
func normalizeExternalBusinessWriteScopes(items []domain.ExternalBusinessWriteScope) []domain.ExternalBusinessWriteScope {
if len(items) == 0 {
return []domain.ExternalBusinessWriteScope{}
}
normalized := make([]domain.ExternalBusinessWriteScope, 0, len(items))
seenConnections := map[string]int{}
for _, item := range items {
connectionID := strings.TrimSpace(item.ConnectionID)
if connectionID == "" {
continue
}
collections := make([]string, 0, len(item.Collections))
seenCollections := map[string]struct{}{}
for _, collection := range item.Collections {
trimmed := strings.TrimSpace(collection)
if trimmed == "" {
continue
}
if _, exists := seenCollections[trimmed]; exists {
continue
}
seenCollections[trimmed] = struct{}{}
collections = append(collections, trimmed)
}
sort.Strings(collections)
if len(collections) == 0 {
continue
}
if index, exists := seenConnections[connectionID]; exists {
existingCollections := normalized[index].Collections
for _, collection := range collections {
if slicesContains(existingCollections, collection) {
continue
}
existingCollections = append(existingCollections, collection)
}
sort.Strings(existingCollections)
normalized[index].Collections = existingCollections
continue
}
seenConnections[connectionID] = len(normalized)
normalized = append(normalized, domain.ExternalBusinessWriteScope{
ConnectionID: connectionID,
Collections: collections,
})
}
return normalized
}
func slicesContains(items []string, target string) bool {
for _, item := range items {
if item == target {
return true
}
}
return false
}
func (server *server) validateExternalBusinessWriteScopes(ctx context.Context, scopes []domain.ExternalBusinessWriteScope) []validationIssue {
issues := make([]validationIssue, 0)
normalized := normalizeExternalBusinessWriteScopes(scopes)
if len(normalized) == 0 {
return []validationIssue{{Field: "scopes", Message: "at least one connectionId and collection whitelist is required"}}
}
for index, scope := range normalized {
if _, err := server.getMongoConnection(ctx, scope.ConnectionID); err != nil {
issues = append(issues, validationIssue{
Field: fmt.Sprintf("scopes[%d].connectionId", index),
Message: "connectionId must reference an existing mongo connection",
})
}
if len(scope.Collections) == 0 {
issues = append(issues, validationIssue{
Field: fmt.Sprintf("scopes[%d].collections", index),
Message: "at least one collection is required",
})
}
}
return issues
}
func validateExternalBusinessWriteObject(field string, value map[string]any, requireNonEmpty bool) []validationIssue {
if value == nil {
if requireNonEmpty {
return []validationIssue{{Field: field, Message: field + " is required"}}
}
return nil
}
if requireNonEmpty && len(value) == 0 {
return []validationIssue{{Field: field, Message: field + " is required"}}
}
issues := make([]validationIssue, 0)
for key := range value {
if strings.HasPrefix(strings.TrimSpace(key), "$") {
issues = append(issues, validationIssue{
Field: field,
Message: field + " cannot contain Mongo operator keys",
})
break
}
}
return issues
}
func externalBusinessWriteTokenEnabled(value *bool) bool {
if value == nil {
return true
}
return *value
}
func externalBusinessWriteSettings(settings *domain.SettingsRecord) *domain.ExternalBusinessWriteSettings {
if settings == nil {
return &domain.ExternalBusinessWriteSettings{Tokens: []domain.ExternalBusinessWriteTokenRecord{}}
}
if settings.ExternalBusinessWrite.Tokens == nil {
settings.ExternalBusinessWrite.Tokens = []domain.ExternalBusinessWriteTokenRecord{}
}
return &settings.ExternalBusinessWrite
}
func findExternalBusinessWriteTokenByID(settings *domain.SettingsRecord, tokenID string) (int, *domain.ExternalBusinessWriteTokenRecord) {
config := externalBusinessWriteSettings(settings)
for index := range config.Tokens {
if config.Tokens[index].ID == tokenID {
return index, &config.Tokens[index]
}
}
return -1, nil
}
func findExternalBusinessWriteTokenByAPIKey(settings *domain.SettingsRecord, apiKey string) *domain.ExternalBusinessWriteTokenRecord {
config := externalBusinessWriteSettings(settings)
hash := externalBusinessWriteAPIKeyHash(apiKey)
for index := range config.Tokens {
item := &config.Tokens[index]
if !item.Enabled || strings.TrimSpace(item.TokenHash) == "" {
continue
}
if subtle.ConstantTimeCompare([]byte(item.TokenHash), []byte(hash)) == 1 {
return item
}
}
return nil
}
func currentExternalBusinessWriteToken(request *http.Request) *domain.ExternalBusinessWriteTokenRecord {
item, _ := request.Context().Value(externalBusinessWriteTokenContextKey{}).(*domain.ExternalBusinessWriteTokenRecord)
return item
}
func externalBusinessWriteAllowed(token *domain.ExternalBusinessWriteTokenRecord, connectionID string, collection string) bool {
if token == nil {
return false
}
targetConnectionID := strings.TrimSpace(connectionID)
targetCollection := strings.TrimSpace(collection)
for _, scope := range token.Scopes {
if strings.TrimSpace(scope.ConnectionID) != targetConnectionID {
continue
}
for _, allowedCollection := range scope.Collections {
if strings.TrimSpace(allowedCollection) == targetCollection {
return true
}
}
}
return false
}
func (server *server) touchExternalBusinessWriteToken(ctx context.Context, tokenID string) {
settings, err := server.store.GetSettings(ctx)
if err != nil {
return
}
index, item := findExternalBusinessWriteTokenByID(settings, tokenID)
if item == nil {
return
}
now := nowISO()
settings.ExternalBusinessWrite.Tokens[index].LastUsedAt = now
settings.ExternalBusinessWrite.Tokens[index].UpdatedAt = now
_ = server.store.UpsertSettings(ctx, *settings)
}
func (server *server) externalBusinessWriteAuth(next http.Handler) http.Handler {
return http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
apiKey := strings.TrimSpace(request.Header.Get("X-API-Key"))
if apiKey == "" {
renderJSON(writer, http.StatusUnauthorized, map[string]string{"error": "X-API-Key header is required"})
return
}
settings, err := server.store.GetSettings(request.Context())
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
token := findExternalBusinessWriteTokenByAPIKey(settings, apiKey)
if token == nil {
renderJSON(writer, http.StatusUnauthorized, map[string]string{"error": "invalid API key"})
return
}
tokenCopy := *token
ctx := context.WithValue(request.Context(), externalBusinessWriteTokenContextKey{}, &tokenCopy)
next.ServeHTTP(writer, request.WithContext(ctx))
})
}
func (server *server) handleExternalBusinessWriteTokensList(writer http.ResponseWriter, request *http.Request) {
settings, err := server.store.GetSettings(request.Context())
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusOK, externalBusinessWriteTokensResult{
Items: sanitizeExternalBusinessWriteTokens(settings.ExternalBusinessWrite.Tokens),
})
}
func (server *server) handleExternalBusinessWriteTokensCreate(writer http.ResponseWriter, request *http.Request) {
var payload externalBusinessWriteTokenCreateRequest
if !decodeJSON(writer, request, &payload) {
return
}
normalizedScopes := normalizeExternalBusinessWriteScopes(payload.Scopes)
issues := make([]validationIssue, 0)
if strings.TrimSpace(payload.Name) == "" {
issues = append(issues, validationIssue{Field: "name", Message: "name is required"})
}
issues = append(issues, server.validateExternalBusinessWriteScopes(request.Context(), normalizedScopes)...)
if len(issues) > 0 {
renderValidationError(writer, issues...)
return
}
apiKey, tokenHash, tokenPreview, err := generateExternalBusinessWriteAPIKey()
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
settings, err := server.store.GetSettings(request.Context())
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
now := nowISO()
item := domain.ExternalBusinessWriteTokenRecord{
ID: domain.NewID("exttoken"),
Name: strings.TrimSpace(payload.Name),
Description: strings.TrimSpace(payload.Description),
Enabled: externalBusinessWriteTokenEnabled(payload.Enabled),
TokenValue: apiKey,
TokenHash: tokenHash,
TokenPreview: tokenPreview,
Scopes: normalizedScopes,
CreatedAt: now,
UpdatedAt: now,
}
settings.ExternalBusinessWrite.Tokens = append(settings.ExternalBusinessWrite.Tokens, item)
if err := server.store.UpsertSettings(request.Context(), *settings); err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusCreated, externalBusinessWriteTokenMutationResult{
Token: sanitizeExternalBusinessWriteToken(item),
APIKey: apiKey,
})
}
func (server *server) handleExternalBusinessWriteTokensUpdate(writer http.ResponseWriter, request *http.Request) {
settings, err := server.store.GetSettings(request.Context())
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
index, item := findExternalBusinessWriteTokenByID(settings, chi.URLParam(request, "id"))
if item == nil {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "External write token not found"})
return
}
var payload externalBusinessWriteTokenUpdateRequest
if !decodeJSON(writer, request, &payload) {
return
}
updated := *item
if payload.Name != nil {
updated.Name = strings.TrimSpace(*payload.Name)
}
if payload.Description != nil {
updated.Description = strings.TrimSpace(*payload.Description)
}
if payload.Enabled != nil {
updated.Enabled = *payload.Enabled
}
if payload.Scopes != nil {
updated.Scopes = normalizeExternalBusinessWriteScopes(*payload.Scopes)
}
issues := make([]validationIssue, 0)
if strings.TrimSpace(updated.Name) == "" {
issues = append(issues, validationIssue{Field: "name", Message: "name is required"})
}
issues = append(issues, server.validateExternalBusinessWriteScopes(request.Context(), updated.Scopes)...)
if len(issues) > 0 {
renderValidationError(writer, issues...)
return
}
updated.UpdatedAt = nowISO()
settings.ExternalBusinessWrite.Tokens[index] = updated
if err := server.store.UpsertSettings(request.Context(), *settings); err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusOK, externalBusinessWriteTokenMutationResult{
Token: sanitizeExternalBusinessWriteToken(updated),
})
}
func (server *server) handleExternalBusinessWriteTokensReveal(writer http.ResponseWriter, request *http.Request) {
settings, err := server.store.GetSettings(request.Context())
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
_, item := findExternalBusinessWriteTokenByID(settings, chi.URLParam(request, "id"))
if item == nil {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "External write token not found"})
return
}
apiKey := strings.TrimSpace(item.TokenValue)
if apiKey == "" {
renderJSON(writer, http.StatusConflict, map[string]string{"error": "该 Token 创建于仅支持预览的旧版本,请轮换 Key 后再查看完整 Token"})
return
}
renderJSON(writer, http.StatusOK, externalBusinessWriteTokenRevealResult{
TokenID: item.ID,
APIKey: apiKey,
})
}
func (server *server) handleExternalBusinessWriteTokensRotate(writer http.ResponseWriter, request *http.Request) {
settings, err := server.store.GetSettings(request.Context())
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
index, item := findExternalBusinessWriteTokenByID(settings, chi.URLParam(request, "id"))
if item == nil {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "External write token not found"})
return
}
apiKey, tokenHash, tokenPreview, err := generateExternalBusinessWriteAPIKey()
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
updated := *item
updated.TokenValue = apiKey
updated.TokenHash = tokenHash
updated.TokenPreview = tokenPreview
updated.UpdatedAt = nowISO()
settings.ExternalBusinessWrite.Tokens[index] = updated
if err := server.store.UpsertSettings(request.Context(), *settings); err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusOK, externalBusinessWriteTokenMutationResult{
Token: sanitizeExternalBusinessWriteToken(updated),
APIKey: apiKey,
})
}
func (server *server) handleExternalBusinessWriteTokensDelete(writer http.ResponseWriter, request *http.Request) {
settings, err := server.store.GetSettings(request.Context())
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
index, item := findExternalBusinessWriteTokenByID(settings, chi.URLParam(request, "id"))
if item == nil {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "External write token not found"})
return
}
settings.ExternalBusinessWrite.Tokens = append(settings.ExternalBusinessWrite.Tokens[:index], settings.ExternalBusinessWrite.Tokens[index+1:]...)
if err := server.store.UpsertSettings(request.Context(), *settings); err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
writer.WriteHeader(http.StatusNoContent)
}
func validateExternalBusinessWriteTarget(connectionID string, collection string) []validationIssue {
issues := make([]validationIssue, 0, 2)
if strings.TrimSpace(connectionID) == "" {
issues = append(issues, validationIssue{Field: "connectionId", Message: "connectionId is required"})
}
if strings.TrimSpace(collection) == "" {
issues = append(issues, validationIssue{Field: "collection", Message: "collection is required"})
}
return issues
}
func (server *server) renderExternalBusinessWriteForbidden(writer http.ResponseWriter) {
renderJSON(writer, http.StatusForbidden, map[string]string{"error": "token is not allowed to write to the requested connection or collection"})
}
func (server *server) handleExternalBusinessWriteCreate(writer http.ResponseWriter, request *http.Request) {
var payload externalBusinessWriteCreateRequest
if !decodeJSON(writer, request, &payload) {
return
}
issues := validateExternalBusinessWriteTarget(payload.ConnectionID, payload.Collection)
issues = append(issues, validateExternalBusinessWriteObject("document", payload.Document, true)...)
if len(issues) > 0 {
renderValidationError(writer, issues...)
return
}
if !externalBusinessWriteAllowed(currentExternalBusinessWriteToken(request), payload.ConnectionID, payload.Collection) {
server.renderExternalBusinessWriteForbidden(writer)
return
}
browserStore, _, cleanup, err := server.resolveBusinessDatabaseStore(request.Context(), payload.ConnectionID)
if err != nil {
renderValidationError(writer, validationIssue{Field: "connectionId", Message: err.Error()})
return
}
defer cleanup()
document, err := browserStore.InsertDatabaseDocument(request.Context(), payload.Collection, payload.Document)
if err != nil {
renderDatabaseBrowserWriteError(writer, err)
return
}
if token := currentExternalBusinessWriteToken(request); token != nil {
server.touchExternalBusinessWriteToken(request.Context(), token.ID)
}
renderJSON(writer, http.StatusCreated, externalBusinessWriteDocumentResult{
ConnectionID: strings.TrimSpace(payload.ConnectionID),
Collection: strings.TrimSpace(payload.Collection),
Operation: "created",
Document: document,
})
}
func (server *server) handleExternalBusinessWritePatch(writer http.ResponseWriter, request *http.Request) {
var payload externalBusinessWritePatchRequest
if !decodeJSON(writer, request, &payload) {
return
}
issues := validateExternalBusinessWriteTarget(payload.ConnectionID, payload.Collection)
issues = append(issues, validateExternalBusinessWriteObject("patch", payload.Patch, true)...)
if len(issues) > 0 {
renderValidationError(writer, issues...)
return
}
if !externalBusinessWriteAllowed(currentExternalBusinessWriteToken(request), payload.ConnectionID, payload.Collection) {
server.renderExternalBusinessWriteForbidden(writer)
return
}
browserStore, _, cleanup, err := server.resolveBusinessDatabaseStore(request.Context(), payload.ConnectionID)
if err != nil {
renderValidationError(writer, validationIssue{Field: "connectionId", Message: err.Error()})
return
}
defer cleanup()
document, err := browserStore.PatchDatabaseDocument(request.Context(), payload.Collection, chi.URLParam(request, "documentId"), payload.Patch)
if err != nil {
renderDatabaseBrowserWriteError(writer, err)
return
}
if token := currentExternalBusinessWriteToken(request); token != nil {
server.touchExternalBusinessWriteToken(request.Context(), token.ID)
}
renderJSON(writer, http.StatusOK, externalBusinessWriteDocumentResult{
ConnectionID: strings.TrimSpace(payload.ConnectionID),
Collection: strings.TrimSpace(payload.Collection),
Operation: "updated",
Document: document,
})
}
func (server *server) handleExternalBusinessWriteUpsert(writer http.ResponseWriter, request *http.Request) {
var payload externalBusinessWriteUpsertRequest
if !decodeJSON(writer, request, &payload) {
return
}
issues := validateExternalBusinessWriteTarget(payload.ConnectionID, payload.Collection)
issues = append(issues, validateExternalBusinessWriteObject("match", payload.Match, true)...)
issues = append(issues, validateExternalBusinessWriteObject("patch", payload.Patch, true)...)
issues = append(issues, validateExternalBusinessWriteObject("setOnInsert", payload.SetOnInsert, false)...)
if len(issues) > 0 {
renderValidationError(writer, issues...)
return
}
if !externalBusinessWriteAllowed(currentExternalBusinessWriteToken(request), payload.ConnectionID, payload.Collection) {
server.renderExternalBusinessWriteForbidden(writer)
return
}
browserStore, _, cleanup, err := server.resolveBusinessDatabaseStore(request.Context(), payload.ConnectionID)
if err != nil {
renderValidationError(writer, validationIssue{Field: "connectionId", Message: err.Error()})
return
}
defer cleanup()
document, created, err := browserStore.UpsertDatabaseDocument(request.Context(), payload.Collection, payload.Match, payload.Patch, payload.SetOnInsert)
if err != nil {
renderDatabaseBrowserWriteError(writer, err)
return
}
if token := currentExternalBusinessWriteToken(request); token != nil {
server.touchExternalBusinessWriteToken(request.Context(), token.ID)
}
operation := "updated"
if created {
operation = "created"
}
renderJSON(writer, http.StatusOK, externalBusinessWriteDocumentResult{
ConnectionID: strings.TrimSpace(payload.ConnectionID),
Collection: strings.TrimSpace(payload.Collection),
Operation: operation,
Document: document,
})
}