feat: Allow relation alias on create and update

Makefile

@@ -175,6 +175,10 @@ endif
 test:
 	gotestsum --format pkgname -- $(DEFAULT_TEST_DIRECTORIES) $(TEST_FLAGS)
 
+.PHONY: test\:quick
+test\:quick:
+	gotestsum --format pkgname -- $(DEFAULT_TEST_DIRECTORIES)
+
 # Only build the tests (don't execute them).
 .PHONY: test\:build
 test\:build:

client/document.go

@@ -17,7 +17,9 @@
 
 	"github.com/fxamacker/cbor/v2"
 	"github.com/ipfs/go-cid"
-	mh "github.com/multiformats/go-multihash"
+
+	"github.com/sourcenetwork/defradb/client/request"
+	ccid "github.com/sourcenetwork/defradb/core/cid"
 )
 
 // This is the main implementation starting point for accessing the internal Document API
@@ -106,26 +108,12 @@
 		return nil, err
 	}
 
-	// if no key was specified, then we assume it doesn't exist and we generate it.
+	// if no key was specified, then we assume it doesn't exist and we generate, and set it.
 	if !hasKey {
-		pref := cid.Prefix{
-			Version:  1,
-			Codec:    cid.Raw,
-			MhType:   mh.SHA2_256,
-			MhLength: -1, // default length
-		}
-
-		buf, err := doc.Bytes()
-		if err != nil {
-			return nil, err
-		}
-
-		// And then feed it some data
-		c, err := pref.Sum(buf)
+		err = doc.generateAndSetDocKey()
 		if err != nil {
 			return nil, err
 		}
-		doc.key = NewDocKeyV0(c)
 	}
 
 	return doc, nil
@@ -257,11 +245,6 @@
 	return nil
 }
 
-// SetAsType Sets the value of a field along with a specific type
-// func (doc *Document) SetAsType(t client.CType, field string, value any) error {
-// 	return doc.set(t, field, value)
-// }
-
 func (doc *Document) set(t CType, field string, value Value) error {
 	doc.mu.Lock()
 	defer doc.mu.Unlock()
@@ -479,6 +462,74 @@
 	return docMap, nil
 }
 
+// GenerateDocKey generates docKey/docID corresponding to the document.
+func (doc *Document) GenerateDocKey() (DocKey, error) {
+	bytes, err := doc.Bytes()
+	if err != nil {
+		return DocKey{}, err
+	}
+
+	cid, err := ccid.NewSHA256CidV1(bytes)
+	if err != nil {
+		return DocKey{}, err
+	}
+
+	return NewDocKeyV0(cid), nil
+}
+
+// setDocKey sets the `doc.key` (should NOT be public).
+func (doc *Document) setDocKey(docID DocKey) {
+	doc.mu.Lock()
+	defer doc.mu.Unlock()
+
+	doc.key = docID
+}
+
+// generateAndSetDocKey generates the docKey/docID and then (re)sets `doc.key`.
+func (doc *Document) generateAndSetDocKey() error {
+	docKey, err := doc.GenerateDocKey()
+	if err != nil {
+		return err
+	}
+
+	doc.setDocKey(docKey)
+	return nil
+}
+
+func (doc *Document) remapAliasFields(fieldDescriptions []FieldDescription) (bool, error) {
+	doc.mu.Lock()
+	defer doc.mu.Unlock()
+
+	foundAlias := false
+	for docField, docFieldValue := range doc.fields {
+		for _, fieldDescription := range fieldDescriptions {
+			maybeAliasField := docField + request.RelatedObjectID
+			if fieldDescription.Name == maybeAliasField {
+				foundAlias = true
+				doc.fields[maybeAliasField] = docFieldValue
+				delete(doc.fields, docField)
+			}
+		}
+	}
+
+	return foundAlias, nil
+}
+
+// RemapAliasFieldsAndDockey remaps the alias fields and fixes (overwrites) the dockey.
+func (doc *Document) RemapAliasFieldsAndDockey(fieldDescriptions []FieldDescription) error {
+	foundAlias, err := doc.remapAliasFields(fieldDescriptions)
+	if err != nil {
+		return err
+	}
+
+	if !foundAlias {
+		return nil
+	}
+
+	// Update the dockey so dockey isn't based on an aliased name of a field.
+	return doc.generateAndSetDocKey()
+}
+
 // DocumentStatus represent the state of the document in the DAG store.
 // It can either be `Active“ or `Deleted`.
 type DocumentStatus uint8

client/document_test.go

@@ -13,9 +13,9 @@ package client
 import (
 	"testing"
 
-	"github.com/ipfs/go-cid"
-	mh "github.com/multiformats/go-multihash"
 	"github.com/stretchr/testify/assert"
+
+	ccid "github.com/sourcenetwork/defradb/core/cid"
 )
 
 var (
@@ -28,12 +28,7 @@ var (
 		}
 	}`)
 
-	pref = cid.Prefix{
-		Version:  1,
-		Codec:    cid.Raw,
-		MhType:   mh.SHA2_256,
-		MhLength: -1, // default length
-	}
+	pref = ccid.NewDefaultSHA256PrefixV1()
 )
 
 func TestNewFromJSON(t *testing.T) {

client/errors.go

@@ -17,34 +17,32 @@ import (
 )
 
 const (
-	errFieldNotExist         string = "The given field does not exist"
-	errSelectOfNonGroupField string = "cannot select a non-group-by field at group-level"
-	errUnexpectedType        string = "unexpected type"
-	errParsingFailed         string = "failed to parse argument"
-	errUninitializeProperty  string = "invalid state, required property is uninitialized"
-	errMaxTxnRetries         string = "reached maximum transaction reties"
+	errFieldNotExist        string = "The given field does not exist"
+	errUnexpectedType       string = "unexpected type"
+	errParsingFailed        string = "failed to parse argument"
+	errUninitializeProperty string = "invalid state, required property is uninitialized"
+	errMaxTxnRetries        string = "reached maximum transaction reties"
 )
 
 // Errors returnable from this package.
 //
 // This list is incomplete and undefined errors may also be returned.
 // Errors returned from this package may be tested against these errors with errors.Is.
 var (
-	ErrFieldNotExist         = errors.New(errFieldNotExist)
-	ErrSelectOfNonGroupField = errors.New(errSelectOfNonGroupField)
-	ErrUnexpectedType        = errors.New(errUnexpectedType)
-	ErrParsingFailed         = errors.New(errParsingFailed)
-	ErrUninitializeProperty  = errors.New(errUninitializeProperty)
-	ErrFieldNotObject        = errors.New("trying to access field on a non object type")
-	ErrValueTypeMismatch     = errors.New("value does not match indicated type")
-	ErrIndexNotFound         = errors.New("no index found for given ID")
-	ErrDocumentNotFound      = errors.New("no document for the given key exists")
-	ErrInvalidUpdateTarget   = errors.New("the target document to update is of invalid type")
-	ErrInvalidUpdater        = errors.New("the updater of a document is of invalid type")
-	ErrInvalidDeleteTarget   = errors.New("the target document to delete is of invalid type")
-	ErrMalformedDocKey       = errors.New("malformed DocKey, missing either version or cid")
-	ErrInvalidDocKeyVersion  = errors.New("invalid DocKey version")
-	ErrMaxTxnRetries         = errors.New(errMaxTxnRetries)
+	ErrFieldNotExist        = errors.New(errFieldNotExist)
+	ErrUnexpectedType       = errors.New(errUnexpectedType)
+	ErrParsingFailed        = errors.New(errParsingFailed)
+	ErrUninitializeProperty = errors.New(errUninitializeProperty)
+	ErrFieldNotObject       = errors.New("trying to access field on a non object type")
+	ErrValueTypeMismatch    = errors.New("value does not match indicated type")
+	ErrIndexNotFound        = errors.New("no index found for given ID")
+	ErrDocumentNotFound     = errors.New("no document for the given key exists")
+	ErrInvalidUpdateTarget  = errors.New("the target document to update is of invalid type")
+	ErrInvalidUpdater       = errors.New("the updater of a document is of invalid type")
+	ErrInvalidDeleteTarget  = errors.New("the target document to delete is of invalid type")
+	ErrMalformedDocKey      = errors.New("malformed DocKey, missing either version or cid")
+	ErrInvalidDocKeyVersion = errors.New("invalid DocKey version")
+	ErrMaxTxnRetries        = errors.New(errMaxTxnRetries)
 )
 
 // NewErrFieldNotExist returns an error indicating that the given field does not exist.
@@ -58,12 +56,6 @@ func NewErrFieldIndexNotExist(index int) error {
 	return errors.New(errFieldNotExist, errors.NewKV("Index", index))
 }
 
-// NewErrSelectOfNonGroupField returns an error indicating that a non-group-by field
-// was selected at group-level.
-func NewErrSelectOfNonGroupField(name string) error {
-	return errors.New(errSelectOfNonGroupField, errors.NewKV("Field", name))
-}
-
 // NewErrUnexpectedType returns an error indicating that the given value is of an unexpected type.
 func NewErrUnexpectedType[TExpected any](property string, actual any) error {
 	var expected TExpected

client/request/errors.go

@@ -0,0 +1,33 @@
+// Copyright 2023 Democratized Data Foundation
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+package request
+
+import (
+	"github.com/sourcenetwork/defradb/errors"
+)
+
+const (
+	errSelectOfNonGroupField string = "cannot select a non-group-by field at group-level"
+)
+
+// Errors returnable from this package.
+//
+// This list is incomplete and undefined errors may also be returned.
+// Errors returned from this package may be tested against these errors with errors.Is.
+var (
+	ErrSelectOfNonGroupField = errors.New(errSelectOfNonGroupField)
+)
+
+// NewErrSelectOfNonGroupField returns an error indicating that a non-group-by field
+// was selected at group-level.
+func NewErrSelectOfNonGroupField(name string) error {
+	return errors.New(errSelectOfNonGroupField, errors.NewKV("Field", name))
+}

client/request/select.go

@@ -12,8 +12,6 @@ package request
 
 import (
 	"github.com/sourcenetwork/immutable"
-
-	"github.com/sourcenetwork/defradb/client"
 )
 
 // SelectionType is the type of selection.
@@ -100,7 +98,7 @@ func (s *Select) validateGroupBy() []error {
 				}
 			}
 			if !fieldExistsInGroupBy && !isAliasFieldInGroupBy {
-				result = append(result, client.NewErrSelectOfNonGroupField(typedChildSelection.Name))
+				result = append(result, NewErrSelectOfNonGroupField(typedChildSelection.Name))
 			}
 		default:
 			// Do nothing

core/cid.go → core/cid/cid.go

@@ -8,22 +8,24 @@
 // by the Apache License, Version 2.0, included in the file
 // licenses/APL.txt.
 
-package core
+package cid
 
 import (
 	"github.com/ipfs/go-cid"
 	mh "github.com/multiformats/go-multihash"
 )
 
-// NewSHA256CidV1 returns a new CIDv1 with the SHA256 multihash.
-func NewSHA256CidV1(data []byte) (cid.Cid, error) {
-	pref := cid.Prefix{
+func NewDefaultSHA256PrefixV1() cid.Prefix {
+	return cid.Prefix{
 		Version:  1,
 		Codec:    cid.Raw,
 		MhType:   mh.SHA2_256,
 		MhLength: -1, // default length
 	}
+}
 
+// NewSHA256CidV1 returns a new CIDv1 with the SHA256 multihash.
+func NewSHA256CidV1(data []byte) (cid.Cid, error) {
 	// And then feed it some data
-	return pref.Sum(data)
+	return NewDefaultSHA256PrefixV1().Sum(data)
 }