Merge branch 'CBG-4411' into CBG-4412

Author: RIT3shSapata

base/error.go

@@ -83,12 +83,6 @@ var (
 
 	// ErrInvalidJSON is returned when the JSON being unmarshalled cannot be parsed.
 	ErrInvalidJSON = HTTPErrorf(http.StatusBadRequest, "Invalid JSON")
-
-	// ErrSyncFnDryRun is returned when the Sync Function Dry Run returns an error while computing the access
-	ErrSyncFnDryRun = &sgError{"Error returned from Sync Function:"}
-
-	// ErrImportDryRun is returned when the Import Filter  Dry Run returns an error when trying to import a document
-	ErrImportDryRun = &sgError{"Error occured during import dry run: "}
 )
 
 func (e *sgError) Error() string {
@@ -367,3 +361,28 @@ func (me *MultiError) ErrorOrNil() error {
 	}
 	return me
 }
+
+const syncFnDryRunErrorPrefix = "Error returned from Sync Function"
+
+// SyncFnDryRunError is returned when the sync function dry run returns an error.
+// It wraps the original error for errors.Is and the type supports errors.As
+type SyncFnDryRunError struct {
+	Err error
+}
+
+func (e *SyncFnDryRunError) Error() string {
+	if e == nil {
+		return syncFnDryRunErrorPrefix
+	}
+	if e.Err == nil {
+		return syncFnDryRunErrorPrefix
+	}
+	return syncFnDryRunErrorPrefix + ": " + e.Err.Error()
+}
+
+func (e *SyncFnDryRunError) Unwrap() error {
+	if e == nil {
+		return nil
+	}
+	return e.Err
+}

db/crud.go

@@ -1694,58 +1694,11 @@ func (db *DatabaseCollectionWithUser) PutExistingRevWithBody(ctx context.Context
 
 }
 
-// SyncFnDryrun Runs a document through the sync function and returns expiry, channels doc was placed in, access map for users, roles, handler errors and sync fn exceptions.
-// If a docID is a non empty string, the document will be fetched from the bucket, otherwise the body will be used. If both are specified, this function returns an error.
-// The first error return value represents an error that occurs before the sync function is run. The second error return value represents an exception from the sync function.
-func (db *DatabaseCollectionWithUser) SyncFnDryrun(ctx context.Context, oldDoc *Document, body Body, docID, syncFn string) (*channels.ChannelMapperOutput, error) {
+// SyncFnDryrun Runs the given document body through a sync function and returns expiry, channels doc was placed in,
+// access map for users, roles, handler errors and sync fn exceptions.
+// If syncFn is provided, it will be used instead of the one configured on the database.
+func (db *DatabaseCollectionWithUser) SyncFnDryrun(ctx context.Context, newDoc, oldDoc *Document, syncFn string) (*channels.ChannelMapperOutput, error) {
 
-	delete(body, BodyId)
-
-	// Get the revision ID to match, and the new generation number:
-	matchRev, _ := body[BodyRev].(string)
-	generation, _ := ParseRevID(ctx, matchRev)
-	if generation < 0 {
-		return nil, base.HTTPErrorf(http.StatusBadRequest, "Invalid revision ID")
-	}
-	generation++
-
-	// Create newDoc which will be used to pass around Body
-	newDoc := &Document{
-		ID: docID,
-	}
-	// Pull out attachments
-	newDoc.SetAttachments(GetBodyAttachments(body))
-	delete(body, BodyAttachments)
-
-	delete(body, BodyRevisions)
-
-	err := validateAPIDocUpdate(body)
-	if err != nil {
-		return nil, err
-	}
-	bodyWithoutInternalProps, wasStripped := StripInternalProperties(body)
-	canonicalBytesForRevID, err := base.JSONMarshalCanonical(bodyWithoutInternalProps)
-	if err != nil {
-		return nil, err
-	}
-
-	// We needed to keep _deleted around in the body until we generated a rev ID, but now we can ditch it.
-	_, isDeleted := body[BodyDeleted]
-	if isDeleted {
-		delete(body, BodyDeleted)
-	}
-
-	// and now we can finally update the newDoc body to be without any special properties
-	newDoc.UpdateBody(body)
-
-	// If no special properties were stripped and document wasn't deleted, the canonical bytes represent the current
-	// body.  In this scenario, store canonical bytes as newDoc._rawBody
-	if !wasStripped && !isDeleted {
-		newDoc._rawBody = canonicalBytesForRevID
-	}
-
-	newRev := CreateRevIDWithBytes(generation, matchRev, canonicalBytesForRevID)
-	newDoc.RevID = newRev
 	mutableBody, metaMap, _, err := db.prepareSyncFn(oldDoc, newDoc)
 	if err != nil {
 		base.InfofCtx(ctx, base.KeyDiagnostic, "Failed to prepare to run sync function: %v", err)
@@ -1761,7 +1714,7 @@ func (db *DatabaseCollectionWithUser) SyncFnDryrun(ctx context.Context, oldDoc *
 	if syncFn == "" {
 		output, err = db.ChannelMapper.MapToChannelsAndAccess(ctx, mutableBody, string(oldDoc._rawBody), metaMap, syncOptions)
 		if err != nil {
-			syncErr = fmt.Errorf("%s%s", base.ErrSyncFnDryRun, err)
+			return nil, &base.SyncFnDryRunError{Err: err}
 		}
 	} else {
 		jsTimeout := time.Duration(base.DefaultJavascriptTimeoutSecs) * time.Second
@@ -1771,7 +1724,8 @@ func (db *DatabaseCollectionWithUser) SyncFnDryrun(ctx context.Context, oldDoc *
 		}
 		jsOutput, err := syncRunner.Call(ctx, mutableBody, string(oldDoc._rawBody), metaMap, syncOptions)
 		if err != nil {
-			syncErr = fmt.Errorf("%s%s", base.ErrSyncFnDryRun, err)
+
+			return nil, fmt.Errorf("failed to create sync runner: %v", err)
 		}
 		output = jsOutput.(*channels.ChannelMapperOutput)
 	}

docs/api/paths/diagnostic/keyspace-sync.yaml

@@ -7,6 +7,7 @@
 # the file licenses/APL2.txt.
 parameters:
   - $ref: ../../components/parameters.yaml#/keyspace
+  - $ref: ../../components/parameters.yaml#/doc_id
 post:
   summary: Run a doc body through the sync function and return sync data.
   description: |-

rest/diagnostic_doc_api.go

@@ -11,9 +11,9 @@ licenses/APL2.txt.
 package rest
 
 import (
-	"mime"
+	"errors"
+	"fmt"
 	"net/http"
-	"strings"
 
 	"github.com/couchbase/sync_gateway/auth"
 	"github.com/couchbase/sync_gateway/base"
@@ -80,20 +80,19 @@ func (h *handler) handleGetDocChannels() error {
 // If docid is specified and the document does not exist in the bucket, it will return error
 func (h *handler) handleSyncFnDryRun() error {
 	docid := h.getQuery("doc_id")
-	contentType, _, _ := mime.ParseMediaType(h.rq.Header.Get("Content-Type"))
-
-	if contentType != "application/json" && contentType != "" {
-		return base.HTTPErrorf(http.StatusUnsupportedMediaType, "Invalid Content-Type header: %s. Needs to be empty or application/json", contentType)
-	}
 
 	var syncDryRunPayload SyncFnDryRunPayload
 	err := h.readJSONInto(&syncDryRunPayload)
 	// Only require a valid JSON payload if docid is not provided.
 	// If docid is provided, the sync function will use the document from the bucket, and the payload is optional.
-	if err != nil && docid == "" {
+	if err != nil {
 		return base.HTTPErrorf(http.StatusBadRequest, "Error reading sync function payload: %v", err)
 	}
 
+	if syncDryRunPayload.Doc == nil && docid == "" {
+		return base.HTTPErrorf(http.StatusBadRequest, "no docid or document provided")
+	}
+
 	oldDoc := &db.Document{ID: docid}
 	oldDoc.UpdateBody(syncDryRunPayload.Doc)
 	if docid != "" {
@@ -110,17 +109,64 @@ func (h *handler) handleSyncFnDryRun() error {
 		oldDoc.UpdateBody(nil)
 	}
 
-	output, err := h.collection.SyncFnDryrun(h.ctx(), oldDoc, syncDryRunPayload.Doc, docid, syncDryRunPayload.Function)
+	delete(syncDryRunPayload.Doc, db.BodyId)
+
+	// Get the revision ID to match, and the new generation number:
+	matchRev, _ := syncDryRunPayload.Doc[db.BodyRev].(string)
+	generation, _ := db.ParseRevID(h.ctx(), matchRev)
+	if generation < 0 {
+		return base.HTTPErrorf(http.StatusBadRequest, "Invalid revision ID")
+	}
+	generation++
+
+	// Create newDoc which will be used to pass around Body
+	newDoc := &db.Document{
+		ID: docid,
+	}
+	// Pull attachments
+	newDoc.SetAttachments(db.GetBodyAttachments(syncDryRunPayload.Doc))
+	delete(syncDryRunPayload.Doc, db.BodyAttachments)
+	delete(syncDryRunPayload.Doc, db.BodyRevisions)
+
+	if _, ok := syncDryRunPayload.Doc[base.SyncPropertyName]; ok {
+		return base.HTTPErrorf(http.StatusBadRequest, "document-top level property '_sync' is a reserved internal property")
+	}
+
+	db.StripInternalProperties(syncDryRunPayload.Doc)
+
+	// We needed to keep _deleted around in the body until we generate rev ID, but now it can be removed
+	_, isDeleted := syncDryRunPayload.Doc[db.BodyDeleted]
+	if isDeleted {
+		delete(syncDryRunPayload.Doc, db.BodyDeleted)
+	}
+
+	//update the newDoc body to be without any special properties
+	newDoc.UpdateBody(syncDryRunPayload.Doc)
+
+	rawDocBytes, err := newDoc.BodyBytes(h.ctx())
 	if err != nil {
-		if strings.Contains(err.Error(), base.ErrSyncFnDryRun.Error()) {
-			errMsg := strings.ReplaceAll(err.Error(), base.ErrSyncFnDryRun.Error(), "")
-			resp := SyncFnDryRun{
-				Exception: errMsg,
-			}
-			h.writeJSON(resp)
-			return nil
+		return base.HTTPErrorf(http.StatusBadRequest, "Error marshalling document: %v", err)
+	}
+
+	newRev := db.CreateRevIDWithBytes(generation, matchRev, rawDocBytes)
+	newDoc.RevID = newRev
+
+	output, err := h.collection.SyncFnDryrun(h.ctx(), newDoc, oldDoc, syncDryRunPayload.Function)
+	if err != nil {
+		var syncFnDryRunErr *base.SyncFnDryRunError
+		if !errors.As(err, &syncFnDryRunErr) {
+			return err
 		}
-		return err
+
+		errMsg := syncFnDryRunErr.Error()
+		if syncFnDryRunErr.Unwrap() != nil {
+			errMsg = syncFnDryRunErr.Err.Error()
+		}
+		resp := SyncFnDryRun{
+			Exception: errMsg,
+		}
+		h.writeJSON(resp)
+		return nil
 	}
 	errorMsg := ""
 	if output.Rejection != nil {