use canonical terms for memdb datastore

internal/datastore/memdb/memdb.go

@@ -25,20 +25,20 @@ const (
 	tableTransaction  = "transaction"
 	tableNamespace    = "namespaceConfig"
 
-	indexID                    = "id"
-	indexTimestamp             = "timestamp"
-	indexLive                  = "live"
-	indexNamespace             = "namespace"
-	indexNamespaceAndObjectID  = "namespaceAndObjectID"
-	indexNamespaceAndRelation  = "namespaceAndRelation"
-	indexNamespaceAndUsersetID = "namespaceAndUsersetID"
-	indexRelationAndUserset    = "relationAndUserset"
-	indexRelationAndRelation   = "relationAndRelation"
-	indexUsersetNamespace      = "usersetNamespace"
-	indexUsersetRelation       = "usersetRelation"
-	indexUserset               = "userset"
-	indexCreatedTxn            = "createdTxn"
-	indexDeletedTxn            = "deletedTxn"
+	indexID                     = "id"
+	indexTimestamp              = "timestamp"
+	indexLive                   = "live"
+	indexNamespace              = "namespace"
+	indexNamespaceAndResourceID = "namespaceAndResourceID"
+	indexNamespaceAndRelation   = "namespaceAndRelation"
+	indexNamespaceAndSubjectID  = "namespaceAndSubjectID"
+	indexRelationAndSubject     = "relationAndSubject"
+	indexRelationAndRelation    = "relationAndRelation"
+	indexSubjectNamespace       = "subjectNamespace"
+	indexSubjectRelation        = "subjectRelation"
+	indexSubject                = "subject"
+	indexCreatedTxn             = "createdTxn"
+	indexDeletedTxn             = "deletedTxn"
 
 	defaultWatchBufferLength = 128
 
@@ -61,23 +61,23 @@ type transaction struct {
 
 type relationship struct {
 	namespace        string
-	objectID         string
+	resourceID       string
 	relation         string
-	usersetNamespace string
-	usersetObjectID  string
-	usersetRelation  string
+	subjectNamespace string
+	subjectObjectID  string
+	subjectRelation  string
 	createdTxn       uint64
 	deletedTxn       uint64
 }
 
 func tupleEntryFromRelationship(r *v1.Relationship, created, deleted uint64) *relationship {
 	return &relationship{
 		namespace:        r.Resource.ObjectType,
-		objectID:         r.Resource.ObjectId,
+		resourceID:       r.Resource.ObjectId,
 		relation:         r.Relation,
-		usersetNamespace: r.Subject.Object.ObjectType,
-		usersetObjectID:  r.Subject.Object.ObjectId,
-		usersetRelation:  stringz.DefaultEmpty(r.Subject.OptionalRelation, "..."),
+		subjectNamespace: r.Subject.Object.ObjectType,
+		subjectObjectID:  r.Subject.Object.ObjectId,
+		subjectRelation:  stringz.DefaultEmpty(r.Subject.OptionalRelation, "..."),
 		createdTxn:       created,
 		deletedTxn:       deleted,
 	}
@@ -87,15 +87,15 @@ func (t relationship) Relationship() *v1.Relationship {
 	return &v1.Relationship{
 		Resource: &v1.ObjectReference{
 			ObjectType: t.namespace,
-			ObjectId:   t.objectID,
+			ObjectId:   t.resourceID,
 		},
 		Relation: t.relation,
 		Subject: &v1.SubjectReference{
 			Object: &v1.ObjectReference{
-				ObjectType: t.usersetNamespace,
-				ObjectId:   t.usersetObjectID,
+				ObjectType: t.subjectNamespace,
+				ObjectId:   t.subjectObjectID,
 			},
-			OptionalRelation: stringz.Default(t.usersetRelation, "", datastore.Ellipsis),
+			OptionalRelation: stringz.Default(t.subjectRelation, "", datastore.Ellipsis),
 		},
 	}
 }
@@ -104,13 +104,13 @@ func (t relationship) RelationTuple() *v0.RelationTuple {
 	return &v0.RelationTuple{
 		ObjectAndRelation: &v0.ObjectAndRelation{
 			Namespace: t.namespace,
-			ObjectId:  t.objectID,
+			ObjectId:  t.resourceID,
 			Relation:  t.relation,
 		},
 		User: &v0.User{UserOneof: &v0.User_Userset{Userset: &v0.ObjectAndRelation{
-			Namespace: t.usersetNamespace,
-			ObjectId:  t.usersetObjectID,
-			Relation:  t.usersetRelation,
+			Namespace: t.subjectNamespace,
+			ObjectId:  t.subjectObjectID,
+			Relation:  t.subjectRelation,
 		}}},
 	}
 }
@@ -119,11 +119,11 @@ func (t relationship) String() string {
 	return fmt.Sprintf(
 		"%s:%s#%s@%s:%s#%s[%d-%d)",
 		t.namespace,
-		t.objectID,
+		t.resourceID,
 		t.relation,
-		t.usersetNamespace,
-		t.usersetObjectID,
-		t.usersetRelation,
+		t.subjectNamespace,
+		t.subjectObjectID,
+		t.subjectRelation,
 		t.createdTxn,
 		t.deletedTxn,
 	)
@@ -185,11 +185,11 @@ var schema = &memdb.DBSchema{
 					Indexer: &memdb.CompoundIndex{
 						Indexes: []memdb.Indexer{
 							&memdb.StringFieldIndex{Field: "namespace"},
-							&memdb.StringFieldIndex{Field: "objectID"},
+							&memdb.StringFieldIndex{Field: "resourceID"},
 							&memdb.StringFieldIndex{Field: "relation"},
-							&memdb.StringFieldIndex{Field: "usersetNamespace"},
-							&memdb.StringFieldIndex{Field: "usersetObjectID"},
-							&memdb.StringFieldIndex{Field: "usersetRelation"},
+							&memdb.StringFieldIndex{Field: "subjectNamespace"},
+							&memdb.StringFieldIndex{Field: "subjectObjectID"},
+							&memdb.StringFieldIndex{Field: "subjectRelation"},
 							&memdb.UintFieldIndex{Field: "createdTxn"},
 						},
 					},
@@ -200,11 +200,11 @@ var schema = &memdb.DBSchema{
 					Indexer: &memdb.CompoundIndex{
 						Indexes: []memdb.Indexer{
 							&memdb.StringFieldIndex{Field: "namespace"},
-							&memdb.StringFieldIndex{Field: "objectID"},
+							&memdb.StringFieldIndex{Field: "resourceID"},
 							&memdb.StringFieldIndex{Field: "relation"},
-							&memdb.StringFieldIndex{Field: "usersetNamespace"},
-							&memdb.StringFieldIndex{Field: "usersetObjectID"},
-							&memdb.StringFieldIndex{Field: "usersetRelation"},
+							&memdb.StringFieldIndex{Field: "subjectNamespace"},
+							&memdb.StringFieldIndex{Field: "subjectObjectID"},
+							&memdb.StringFieldIndex{Field: "subjectRelation"},
 							&memdb.UintFieldIndex{Field: "deletedTxn"},
 						},
 					},
@@ -214,13 +214,13 @@ var schema = &memdb.DBSchema{
 					Unique:  false,
 					Indexer: &memdb.StringFieldIndex{Field: "namespace"},
 				},
-				indexNamespaceAndObjectID: {
-					Name:   indexNamespaceAndObjectID,
+				indexNamespaceAndResourceID: {
+					Name:   indexNamespaceAndResourceID,
 					Unique: false,
 					Indexer: &memdb.CompoundIndex{
 						Indexes: []memdb.Indexer{
 							&memdb.StringFieldIndex{Field: "namespace"},
-							&memdb.StringFieldIndex{Field: "objectID"},
+							&memdb.StringFieldIndex{Field: "resourceID"},
 						},
 					},
 				},
@@ -234,57 +234,57 @@ var schema = &memdb.DBSchema{
 						},
 					},
 				},
-				indexNamespaceAndUsersetID: {
-					Name:   indexNamespaceAndUsersetID,
+				indexNamespaceAndSubjectID: {
+					Name:   indexNamespaceAndSubjectID,
 					Unique: false,
 					Indexer: &memdb.CompoundIndex{
 						Indexes: []memdb.Indexer{
 							&memdb.StringFieldIndex{Field: "namespace"},
-							&memdb.StringFieldIndex{Field: "usersetNamespace"},
-							&memdb.StringFieldIndex{Field: "usersetObjectID"},
+							&memdb.StringFieldIndex{Field: "subjectNamespace"},
+							&memdb.StringFieldIndex{Field: "subjectObjectID"},
 						},
 					},
 				},
-				indexRelationAndUserset: {
-					Name:   indexRelationAndUserset,
+				indexRelationAndSubject: {
+					Name:   indexRelationAndSubject,
 					Unique: false,
 					Indexer: &memdb.CompoundIndex{
 						Indexes: []memdb.Indexer{
-							&memdb.StringFieldIndex{Field: "usersetNamespace"},
-							&memdb.StringFieldIndex{Field: "usersetObjectID"},
-							&memdb.StringFieldIndex{Field: "usersetRelation"},
+							&memdb.StringFieldIndex{Field: "subjectNamespace"},
+							&memdb.StringFieldIndex{Field: "subjectObjectID"},
+							&memdb.StringFieldIndex{Field: "subjectRelation"},
 							&memdb.StringFieldIndex{Field: "namespace"},
 							&memdb.StringFieldIndex{Field: "relation"},
 						},
 					},
 				},
-				indexUsersetRelation: {
-					Name:   indexUsersetRelation,
+				indexSubjectRelation: {
+					Name:   indexSubjectRelation,
 					Unique: false,
 					Indexer: &memdb.CompoundIndex{
 						Indexes: []memdb.Indexer{
-							&memdb.StringFieldIndex{Field: "usersetNamespace"},
-							&memdb.StringFieldIndex{Field: "usersetRelation"},
+							&memdb.StringFieldIndex{Field: "subjectNamespace"},
+							&memdb.StringFieldIndex{Field: "subjectRelation"},
 						},
 					},
 				},
-				indexUserset: {
-					Name:   indexUserset,
+				indexSubject: {
+					Name:   indexSubject,
 					Unique: false,
 					Indexer: &memdb.CompoundIndex{
 						Indexes: []memdb.Indexer{
-							&memdb.StringFieldIndex{Field: "usersetNamespace"},
-							&memdb.StringFieldIndex{Field: "usersetObjectID"},
-							&memdb.StringFieldIndex{Field: "usersetRelation"},
+							&memdb.StringFieldIndex{Field: "subjectNamespace"},
+							&memdb.StringFieldIndex{Field: "subjectObjectID"},
+							&memdb.StringFieldIndex{Field: "subjectRelation"},
 						},
 					},
 				},
-				indexUsersetNamespace: {
-					Name:   indexUsersetNamespace,
+				indexSubjectNamespace: {
+					Name:   indexSubjectNamespace,
 					Unique: false,
 					Indexer: &memdb.CompoundIndex{
 						Indexes: []memdb.Indexer{
-							&memdb.StringFieldIndex{Field: "usersetNamespace"},
+							&memdb.StringFieldIndex{Field: "subjectNamespace"},
 						},
 					},
 				},
@@ -293,8 +293,8 @@ var schema = &memdb.DBSchema{
 					Unique: false,
 					Indexer: &memdb.CompoundIndex{
 						Indexes: []memdb.Indexer{
-							&memdb.StringFieldIndex{Field: "usersetNamespace"},
-							&memdb.StringFieldIndex{Field: "usersetRelation"},
+							&memdb.StringFieldIndex{Field: "subjectNamespace"},
+							&memdb.StringFieldIndex{Field: "subjectRelation"},
 							&memdb.StringFieldIndex{Field: "namespace"},
 							&memdb.StringFieldIndex{Field: "relation"},
 						},

internal/datastore/memdb/query.go

@@ -20,7 +20,7 @@ type memdbTupleQuery struct {
 
 	resourceFilter        *v1.RelationshipFilter
 	optionalSubjectFilter *v1.SubjectFilter
-	usersetsFilter        []*v0.ObjectAndRelation
+	subjectsFilter        []*v0.ObjectAndRelation
 	limit                 *uint64
 
 	simulatedLatency time.Duration
@@ -40,28 +40,28 @@ func (mtq memdbTupleQuery) WithSubjectFilter(filter *v1.SubjectFilter) datastore
 		panic("cannot call WithSubjectFilter after WithUsersets")
 	}
 
-	if mtq.usersetsFilter != nil {
+	if mtq.subjectsFilter != nil {
 		panic("called WithSubjectFilter twice")
 	}
 
 	mtq.optionalSubjectFilter = filter
 	return mtq
 }
 
-func (mtq memdbTupleQuery) WithUsersets(usersets []*v0.ObjectAndRelation) datastore.TupleQuery {
+func (mtq memdbTupleQuery) WithUsersets(subjects []*v0.ObjectAndRelation) datastore.TupleQuery {
 	if mtq.optionalSubjectFilter != nil {
 		panic("cannot call WithUsersets after WithSubjectFilter")
 	}
 
-	if mtq.usersetsFilter != nil {
+	if mtq.subjectsFilter != nil {
 		panic("called WithUsersets twice")
 	}
 
-	if len(usersets) == 0 {
-		panic("Given nil or empty usersets")
+	if len(subjects) == 0 {
+		panic("Given nil or empty subjects")
 	}
 
-	mtq.usersetsFilter = usersets
+	mtq.subjectsFilter = subjects
 	return mtq
 }
 
@@ -70,14 +70,14 @@ func iteratorForFilter(txn *memdb.Txn, filter *v1.RelationshipFilter) (memdb.Res
 	case filter.OptionalResourceId != "":
 		return txn.Get(
 			tableRelationship,
-			indexNamespaceAndObjectID,
+			indexNamespaceAndResourceID,
 			filter.ResourceType,
 			filter.OptionalResourceId,
 		)
 	case filter.OptionalSubjectFilter != nil && filter.OptionalSubjectFilter.OptionalSubjectId != "":
 		return txn.Get(
 			tableRelationship,
-			indexNamespaceAndUsersetID,
+			indexNamespaceAndSubjectID,
 			filter.ResourceType,
 			filter.OptionalSubjectFilter.SubjectType,
 			filter.OptionalSubjectFilter.OptionalSubjectId,
@@ -122,29 +122,29 @@ func (mtq memdbTupleQuery) Execute(ctx context.Context) (datastore.TupleIterator
 		filter := relationshipFilter
 
 		switch {
-		case filter.OptionalResourceId != "" && filter.OptionalResourceId != tuple.objectID:
+		case filter.OptionalResourceId != "" && filter.OptionalResourceId != tuple.resourceID:
 			return true
 		case filter.OptionalRelation != "" && filter.OptionalRelation != tuple.relation:
 			return true
 		}
 
 		if subjectFilter := filter.OptionalSubjectFilter; subjectFilter != nil {
 			switch {
-			case subjectFilter.SubjectType != tuple.usersetNamespace:
+			case subjectFilter.SubjectType != tuple.subjectNamespace:
 				return true
-			case subjectFilter.OptionalSubjectId != "" && subjectFilter.OptionalSubjectId != tuple.usersetObjectID:
+			case subjectFilter.OptionalSubjectId != "" && subjectFilter.OptionalSubjectId != tuple.subjectObjectID:
 				return true
-			case subjectFilter.OptionalRelation != nil && stringz.DefaultEmpty(subjectFilter.OptionalRelation.Relation, datastore.Ellipsis) != tuple.usersetRelation:
+			case subjectFilter.OptionalRelation != nil && stringz.DefaultEmpty(subjectFilter.OptionalRelation.Relation, datastore.Ellipsis) != tuple.subjectRelation:
 				return true
 			}
 		}
 
-		if len(mtq.usersetsFilter) > 0 {
+		if len(mtq.subjectsFilter) > 0 {
 			found := false
-			for _, filter := range mtq.usersetsFilter {
-				if filter.Namespace == tuple.usersetNamespace &&
-					filter.ObjectId == tuple.usersetObjectID &&
-					filter.Relation == tuple.usersetRelation {
+			for _, filter := range mtq.subjectsFilter {
+				if filter.Namespace == tuple.subjectNamespace &&
+					filter.ObjectId == tuple.subjectObjectID &&
+					filter.Relation == tuple.subjectRelation {
 					found = true
 					break
 				}

internal/datastore/memdb/reverse_query.go

@@ -54,7 +54,7 @@ func (mtq memdbReverseTupleQuery) Execute(ctx context.Context) (datastore.TupleI
 		if mtq.subObjectID != "" {
 			bestIterator, err = txn.Get(
 				tableRelationship,
-				indexRelationAndUserset,
+				indexRelationAndSubject,
 				mtq.subNamespaceName,
 				mtq.subObjectID,
 				mtq.subRelationName,
@@ -74,22 +74,22 @@ func (mtq memdbReverseTupleQuery) Execute(ctx context.Context) (datastore.TupleI
 	} else if mtq.subObjectID != "" {
 		bestIterator, err = txn.Get(
 			tableRelationship,
-			indexUserset,
+			indexSubject,
 			mtq.subNamespaceName,
 			mtq.subObjectID,
 			mtq.subRelationName,
 		)
 	} else if mtq.subRelationName != "" {
 		bestIterator, err = txn.Get(
 			tableRelationship,
-			indexUsersetRelation,
+			indexSubjectRelation,
 			mtq.subNamespaceName,
 			mtq.subRelationName,
 		)
 	} else {
 		bestIterator, err = txn.Get(
 			tableRelationship,
-			indexUsersetNamespace,
+			indexSubjectNamespace,
 			mtq.subNamespaceName,
 		)
 	}