Method resolvePath

dagql/server.go:2048–2177

(ctx context.Context, self AnyObjectResult, sel Selection)

}

func (s *Server) resolvePath(ctx context.Context, self AnyObjectResult, sel Selection) (res any, rerr error) {
	defer func() {
		if r := recover(); r != nil {
			rerr = PanicError{
				Cause:     r,
				Self:      self,
				Selection: sel,
				Stack:     debug.Stack(),
			}
		}

		if rerr != nil {
			var queryPath ast.Path
			if recipeID, err := self.RecipeID(ctx); err == nil {
				queryPath = append(idToPath(recipeID), ast.PathName(sel.Name()))
			} else {
				queryPath = ast.Path{ast.PathName(sel.Name())}
			}
			rerr = gqlErr(rerr, queryPath)
		}
	}()

	if sel.Selector.Nth != 0 {
		// NOTE: this is explicitly not handled - but it's fine because
		// resolvePath is called from selectors from field parsing, so we
		// shouldn't hit this in practice
		return nil, fmt.Errorf("cannot resolve selector path with nth")
	}

	// __typename returns the concrete type name of the current object.
	if sel.Selector.Field == "__typename" {
		return self.ObjectType().TypeName(), nil
	}

	leaseCtx, release, err := withOperationLease(ctx)
	if err != nil {
		return nil, fmt.Errorf("acquire operation lease: %w", err)
	}
	ctx = leaseCtx
	defer func() {
		if releaseErr := release(context.WithoutCancel(ctx)); releaseErr != nil && rerr == nil {
			rerr = releaseErr
		}
	}()

	val, err := self.Select(ctx, s, sel.Selector)
	if err != nil {
		return nil, err
	}

	if val == nil || val.Unwrap() == nil {
		// a nil value ignores all sub-selections
		return nil, nil
	}

	enum, ok := val.Unwrap().(Enumerable)
	if ok {
		// we're sub-selecting into an enumerable value, so we need to resolve each