fix key namespace, must be same as in parent state mapper (#68)

Author: vitiko

state/mapping/mapping_test.go

@@ -55,10 +55,7 @@ var _ = Describe(`Mapping`, func() {
 		create3 := testdata.CreateEntityWithCompositeId[2]
 
 		It("Allow to get mapping data by namespace", func() {
-			// key base on entity type
-			baseKey := state.Key{`EntityWithCompositeId`}
-
-			mapping, err := testdata.EntityWithCompositeIdStateMapping.GetByNamespace(baseKey)
+			mapping, err := testdata.EntityWithCompositeIdStateMapping.GetByNamespace(testdata.EntityCompositeIdNamespace)
 			Expect(err).NotTo(HaveOccurred())
 			Expect(mapping.Schema()).To(BeEquivalentTo(&schema.EntityWithCompositeId{}))
 
@@ -70,7 +67,8 @@ var _ = Describe(`Mapping`, func() {
 
 			Expect(err).NotTo(HaveOccurred())
 			Expect(key).To(Equal(
-				baseKey.Append(state.Key{create1.IdFirstPart, create1.IdSecondPart, testdata.Dates[0]})))
+				testdata.EntityCompositeIdNamespace.Append(
+					state.Key{create1.IdFirstPart, create1.IdSecondPart, testdata.Dates[0]})))
 		})
 
 		It("Allow to add data to chaincode state", func(done Done) {

state/mapping/state_mapping.go

@@ -75,8 +75,9 @@ type (
 	StateMappingOpt func(*StateMapping, StateMappings)
 )
 
-func mapKey(entry interface{}) string {
-	return reflect.TypeOf(entry).String()
+// mapKey schema string representation
+func mapKey(schema interface{}) string {
+	return reflect.TypeOf(schema).String()
 }
 
 func (smm StateMappings) Add(schema interface{}, opts ...StateMappingOpt) StateMappings {
@@ -96,10 +97,11 @@ func (smm StateMappings) Add(schema interface{}, opts ...StateMappingOpt) StateM
 func applyStateMappingDefaults(sm *StateMapping) {
 	// default namespace based on type name
 	if len(sm.namespace) == 0 {
-		sm.namespace = SchemaNamespace(sm.schema)
+		sm.namespace = sm.DefaultNamespace()
 	}
 }
 
+// SchemaNamespace produces string representation of Schema type
 func SchemaNamespace(schema interface{}) state.Key {
 	t := reflect.TypeOf(schema).String()
 	return state.Key{t[strings.Index(t, `.`)+1:]}
@@ -108,18 +110,15 @@ func SchemaNamespace(schema interface{}) state.Key {
 // Get mapper for mapped entry
 func (smm StateMappings) Get(entry interface{}) (StateMapper, error) {
 	switch id := entry.(type) {
+	// entry is Key, namespace is first element of key
 	case []string:
 		return smm.GetByNamespace(id[0:1])
 	default:
-		m, ok := smm[mapKey(entry)]
-		if !ok {
-			return nil, fmt.Errorf(`%s: %s`, ErrStateMappingNotFound, mapKey(entry))
-		}
-		return m, nil
+		return smm.GetBySchema(entry)
 	}
 }
 
-// Get mapper by string namespace. It can be used in block explorer: we know state key, but don't know
+// GetByNamespace returns mapper by string namespace. It can be used in block explorer: we know state key, but don't know
 // type actually mapped to state
 func (smm StateMappings) GetByNamespace(namespace state.Key) (StateMapper, error) {
 	for _, m := range smm {
@@ -130,6 +129,14 @@ func (smm StateMappings) GetByNamespace(namespace state.Key) (StateMapper, error
 	return nil, fmt.Errorf(`%s: %s`, ErrStateMappingNotFound, namespace)
 }
 
+func (smm StateMappings) GetBySchema(schema interface{}) (StateMapper, error) {
+	m, ok := smm[mapKey(schema)]
+	if !ok {
+		return nil, fmt.Errorf(`%s: %s`, ErrStateMappingNotFound, mapKey(schema))
+	}
+	return m, nil
+}
+
 func (smm StateMappings) Exists(entry interface{}) bool {
 	_, err := smm.Get(entry)
 	return err == nil
@@ -167,6 +174,10 @@ func (sm *StateMapping) Namespace() state.Key {
 	return sm.namespace
 }
 
+func (sm *StateMapping) DefaultNamespace() state.Key {
+	return SchemaNamespace(sm.schema)
+}
+
 func (sm *StateMapping) Indexes() []*StateIndex {
 	return sm.indexes
 }

state/mapping/state_mapping_opt.go

@@ -90,8 +90,18 @@ func PKeySchema(pkeySchema interface{}) StateMappingOpt {
 	return func(sm *StateMapping, smm StateMappings) {
 		sm.primaryKeyer = attrsKeyer(attrs)
 
-		//add mapping namespace for id schema same as schema
-		smm.Add(pkeySchema, StateNamespace(SchemaNamespace(sm.schema)), PKeyAttr(attrs...), KeyerFor(sm.schema))
+		// inherit namespace from "parent" mapping
+		namespace := sm.namespace
+		if len(namespace) == 0 {
+			namespace = sm.DefaultNamespace()
+		}
+
+		//add mapping for schema identifier
+		smm.Add(
+			pkeySchema,
+			StateNamespace(namespace),
+			PKeyAttr(attrs...),
+			KeyerFor(sm.schema))
 	}
 }
 

state/mapping/testdata/cc_composite_id.go

@@ -5,15 +5,19 @@ import (
 	"github.com/s7techlab/cckit/extensions/owner"
 	"github.com/s7techlab/cckit/router"
 	"github.com/s7techlab/cckit/router/param/defparam"
+	"github.com/s7techlab/cckit/state"
 	"github.com/s7techlab/cckit/state/mapping"
 	"github.com/s7techlab/cckit/state/mapping/testdata/schema"
 )
 
 var (
-	EntityWithCompositeIdStateMapping = mapping.StateMappings{}.
-		Add(&schema.EntityWithCompositeId{},
-			mapping.PKeySchema(&schema.EntityCompositeId{}),
-			mapping.List(&schema.EntityWithCompositeIdList{}))
+	EntityCompositeIdNamespace        = state.Key{`entity-composite-id`}
+	EntityWithCompositeIdStateMapping = mapping.StateMappings{}.Add(&schema.EntityWithCompositeId{},
+		// explicit set namespace for primary key, otherwise namespace will be based of schema type string representation
+		mapping.StateNamespace(EntityCompositeIdNamespace),
+		//  schema for Primary Key
+		mapping.PKeySchema(&schema.EntityCompositeId{}),
+		mapping.List(&schema.EntityWithCompositeIdList{}))
 )
 
 func NewCompositeIdCC() *router.Chaincode {