Method toSelectable

dagql/server.go:2184–2217

(ctx context.Context, val AnyResult)

}

func (s *Server) toSelectable(ctx context.Context, val AnyResult) (AnyObjectResult, error) {
	if sel, ok := val.(AnyObjectResult); ok {
		// We always support returning something that's already Selectable, e.g. an
		// object loaded from its ID.
		return sel, nil
	}

	className := val.Type().Name()
	if class, ok := s.ObjectType(className); ok {
		return class.New(val)
	}
	// Current server doesn't know the type; fall back to the class captured on
	// the result's shared payload when it was first wrapped. This handles
	// cross-module cases where the concrete type lives in a module not
	// installed in this server's schema.
	shared := val.cacheSharedResult()
	if shared != nil {
		if state := shared.loadPayloadState(); state.objClass != nil && state.objClass.TypeName() == className {
			return state.objClass.New(val)
		}
	}
	// Last resort: rebuild a dep-aware resolver from the result's call frame.
	// Reached when class capture missed a path; once we resolve here we
	// remember the class on the shared so subsequent hits skip this branch.
	if shared != nil && s.resultServerForCall != nil {
		if depResolver, err := resolverForSharedResultObject(ctx, s, shared, className); err == nil && depResolver != nil {
			if class, ok := depResolver.ObjectType(className); ok {
				shared.setObjClass(class)
				return class.New(val)
			}
		}
	}
	return nil, fmt.Errorf("toSelectable: unknown type %q", className)
}

// typeConditionMatches returns true if the given type condition (from a
// fragment spread or inline fragment) matches the given object type name.