Method BuildRelationPathChain

internal/schema/linked_schema.go:437–497

BuildRelationPathChain builds the complete relation path chain for multi-hop nested attributes

(sourceEntityType, targetEntityType string)

// BuildRelationPathChain builds the complete relation path chain for multi-hop nested attributes
func (g *LinkedSchemaGraph) BuildRelationPathChain(sourceEntityType, targetEntityType string) ([]*base.RelationReference, error) {
	// Try direct relation first
	relationName, err := g.GetInverseRelation(sourceEntityType, targetEntityType)
	if err == nil {
		// Direct relation exists, return single hop
		return []*base.RelationReference{
			{
				Type:     sourceEntityType,
				Relation: relationName,
			},
		}, nil
	}

	// Use BFS to find multi-hop path
	visited := make(map[string]bool)
	queue := []struct {
		entityType string
		path       []*base.RelationReference
	}{{sourceEntityType, []*base.RelationReference{}}}

	visited[sourceEntityType] = true

	for len(queue) > 0 {
		current := queue[0]
		queue = queue[1:]

		if current.entityType == targetEntityType {
			return current.path, nil
		}

		entityDef, exists := g.schema.EntityDefinitions[current.entityType]
		if !exists {
			continue
		}

		// Explore all relations from current entity
		for relationName, relationDef := range entityDef.Relations {
			for _, relRef := range relationDef.RelationReferences {
				nextEntityType := relRef.GetType()
				if !visited[nextEntityType] {
					visited[nextEntityType] = true

					// Build new path
					newPath := make([]*base.RelationReference, len(current.path)+1)
					copy(newPath, current.path)
					newPath[len(current.path)] = &base.RelationReference{
						Type:     current.entityType,
						Relation: relationName,
					}

					queue = append(queue, struct {
						entityType string
						path       []*base.RelationReference
					}{nextEntityType, newPath})
				}
			}
		}
	}