Function resultCallFromRecipeIDInput

dagql/call_request_input.go:106–162

(ctx context.Context, id *call.ID)

}

func resultCallFromRecipeIDInput(ctx context.Context, id *call.ID) (*ResultCall, error) {
	if id == nil {
		return nil, nil
	}
	if id.IsHandle() {
		return nil, fmt.Errorf("handle-form IDs cannot be converted to inline recipe calls: %s", idInputDebugString(id))
	}

	var callType *ResultCallType
	if id.Type() != nil {
		callType = NewResultCallType(id.Type().ToAST())
	}
	frame := &ResultCall{
		Kind:         ResultCallKindField,
		Type:         callType,
		Field:        id.Field(),
		View:         id.View(),
		Nth:          id.Nth(),
		EffectIDs:    id.EffectIDs(),
		ExtraDigests: id.ExtraDigests(),
	}

	if receiver := id.Receiver(); receiver != nil {
		receiverRef, err := resultCallRefFromIDInput(ctx, receiver)
		if err != nil {
			return nil, fmt.Errorf("receiver: %w", err)
		}
		frame.Receiver = receiverRef
	}
	if mod := id.Module(); mod != nil {
		modRef, err := resultCallRefFromIDInput(ctx, mod.ID())
		if err != nil {
			return nil, fmt.Errorf("module: %w", err)
		}
		frame.Module = &ResultCallModule{
			ResultRef: modRef,
			Name:      mod.Name(),
			Ref:       mod.Ref(),
			Pin:       mod.Pin(),
		}
	}
	for _, arg := range id.Args() {
		converted, err := resultCallArgFromRecipeArgument(ctx, arg)
		if err != nil {
			return nil, fmt.Errorf("arg %q: %w", arg.Name(), err)
		}
		frame.Args = append(frame.Args, converted)
	}
	for _, input := range id.ImplicitInputs() {
		converted, err := resultCallArgFromRecipeArgument(ctx, input)
		if err != nil {
			return nil, fmt.Errorf("implicit input %q: %w", input.Name(), err)
		}
		frame.ImplicitInputs = append(frame.ImplicitInputs, converted)
	}
	return frame, nil
}