droboticflow/internal/api/database_external_write.go

637 lines
23 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 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"))
limitKey := server.clientRateLimitKey(request, "external-write:"+externalBusinessWriteAPIKeyHash(apiKey))
if !server.externalWriteLimiter.allow(limitKey) {
renderJSON(writer, http.StatusTooManyRequests, map[string]string{"error": "too many external write requests"})
return
}
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
}
tokens := server.filterExternalBusinessWriteTokensForRequest(request, settings.ExternalBusinessWrite.Tokens)
renderJSON(writer, http.StatusOK, externalBusinessWriteTokensResult{
Items: sanitizeExternalBusinessWriteTokens(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"),
OrganizationID: server.requestOrganizationID(request),
Name: strings.TrimSpace(payload.Name),
Description: strings.TrimSpace(payload.Description),
Enabled: externalBusinessWriteTokenEnabled(payload.Enabled),
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
}
if !server.ensureTenantAccess(writer, request, item.OrganizationID, "External write token") {
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
}
if !server.ensureTenantAccess(writer, request, item.OrganizationID, "External write token") {
return
}
renderJSON(writer, http.StatusGone, map[string]string{"error": "API key is only shown once during create or rotate"})
}
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
}
if !server.ensureTenantAccess(writer, request, item.OrganizationID, "External write token") {
return
}
apiKey, tokenHash, tokenPreview, err := generateExternalBusinessWriteAPIKey()
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
updated := *item
updated.TokenValue = ""
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
}
if !server.ensureTenantAccess(writer, request, item.OrganizationID, "External write token") {
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,
})
}