Function wrapSharedResultWithResolver

dagql/cache.go:1635–1699

(ctx context.Context, res *sharedResult, hitCache bool, resolver TypeResolver)

}

func wrapSharedResultWithResolver(ctx context.Context, res *sharedResult, hitCache bool, resolver TypeResolver) (AnyResult, error) {
	ret := Result[Typed]{
		shared:   res,
		hitCache: hitCache,
	}
	if res == nil {
		return ret, nil
	}
	state := res.loadPayloadState()
	if !state.isObject {
		return ret, nil
	}
	typeName := sharedResultObjectTypeName(res, state)
	if state.self == nil {
		switch {
		case state.persistedEnvelope != nil:
			return nil, fmt.Errorf("reconstruct object result %q: persisted payload has not been decoded", typeName)
		case state.hasValue:
			return nil, fmt.Errorf("reconstruct object result %q: invalid payload state (hasValue=true, self=nil)", typeName)
		default:
			return nil, fmt.Errorf("reconstruct object result %q: missing typed payload", typeName)
		}
	}
	if typeName == "" {
		return nil, fmt.Errorf("reconstruct object result: missing type name")
	}
	// Prefer the current resolver's class so cache hits re-wrap against the
	// reading server (which may have its own per-view/per-server resolvers).
	if resolver != nil {
		if objType, ok := resolver.ObjectType(typeName); ok {
			return objType.New(ret)
		}
	}
	// Resolver doesn't know the type — typically a cross-module hit where the
	// concrete type lives in a module not installed in the caller's schema.
	// Reuse the class captured at result construction; it works regardless of
	// where the result is being read from.
	if state.objClass != nil && state.objClass.TypeName() == typeName {
		return state.objClass.New(ret)
	}
	if resolver == nil {
		return nil, fmt.Errorf("reconstruct object result %q: missing type resolver", typeName)
	}
	// Last resort: rebuild a dep-aware resolver from the result's call frame.
	// Reached when class capture missed a path (e.g., a value materialized in
	// core/object.go's ConvertFromSDKResult against a server that doesn't have
	// the producing module installed, or a persisted import loaded by ID
	// before any class-bearing wrap). The resolved class is cached back so
	// subsequent reconstructions skip this branch.
	depResolver, err := resolverForSharedResultObject(ctx, resolver, res, typeName)
	if err != nil {
		return nil, err
	}
	if depResolver != nil {
		if objType, ok := depResolver.ObjectType(typeName); ok {
			objRes, err := objType.New(ret)
			if err != nil {
				return nil, fmt.Errorf("reconstruct object result %q: %w", typeName, err)