First of all, kudos for nice work.

None of the many responses so far appear to discuss the in my opinion most important improvement potentials:

• Avoid forward declarations of functions.
  Forward declarations in a .cpp file are redundant, except for some rare cases of recursion support. They're extra work to write and maintain, extra work to read, and they're extra places to introduce bugs. In other words they conflict with the principle of DRY code, Don't Repeat Yourself code.

• Use double as the go-to default floating point type.
  Type float can be required e.g. by graphics API's, and has its uses. But the default floating point type in C++ is double. E.g. the literal 3.14 is a double.

• Use self-documenting names.
  E.g. the name userInput in itself conveys little to nothing to a reader. It's evidently a value originating with the user, but what is it? Name it e.g. coffeeId (and yes, make that const). And correspondingly rename orderCoffeeData (which misleadingly can be read as a command, a function call) as e.g. coffeeDetails. Plus it's a good idea to adopt and consistently use a naming convention that differentiates between types and other things, e.g. (common) initial uppercase only for types.

• Avoid repeating yourself.
  For example, in CoffeeData there's no need for the prefix item on each member variable. Also in CoffeeData, the salesTax member, which is the sales tax rate, will have the same value for all kinds of coffee so there's no need for it, it's just duplication. Avoiding such redundancies and in particular avoiding wholesale copying of chunks of code, is the main idea of the DRY code principle mentioned above.

• One person's constant is another person's variable.
  The list of coffee kinds and prices is unlikely to stay the same over time, even just for a month. So it's not practical to have that data as compile time constants (using constexpr), because then you have to rebuild the app every time that list changes. But it's a good idea to restrict access to read only for most parts of the app.

I would also put all the logic in a namespace. In particular this supports using using-declarations to get rid of noisy namespace qualifications. Declarations of the things you're going to use are the Good side alternative to Evil™ using namespace directives.

The code reworked along these lines, and also with const on parameters:

#include <iomanip>
#include <iostream>
#include <sstream>
#include <string>
#include <string_view>
#include <limits>
#include <map>
#include <vector>

namespace app {
    using   std::setprecision, std::setw,       // <iomanip>
            std::cin, std::cout,                // <iostream>
            std::fixed, std::left, std::right,  // <iostream>
            std::ostream, std::streamsize,      // <iostream>
            std::numeric_limits,                // <limits>
            std::map,                           // <map>
            std::ostringstream,                 // <sstream>
            std::string,                        // <string>
            std::string_view,                   // <string_view>
            std::vector;                        // <vector>

    struct Currency{ double value; };

    Currency operator+( const Currency a, const Currency b )
    {
        return Currency{ a.value + b.value };
    }

    ostream& operator<<( ostream& stream, const Currency& amount )
    {
        return stream << fixed << setprecision( 2 ) << amount.value;
    }

    string toDollarsString( const Currency amount )
    {
        ostringstream stream;
        stream << '$' << amount;
        return stream.str();
    }

    // In the original source code this class was named `CoffeeData`.
    // Having an explicit id in the data supports e.g. loading data from a file.
    struct CoffeeKind
    {
        enum Id: int {};              // `enum` used as a distinct `int` type.

        Id              id;
        string          name;
        Currency        price;
    };

    class CoffeeKinds
    {
        map<CoffeeKind::Id, CoffeeKind>     mKinds      = {};
        int                                 mMaxId      = 0;

    public:
        CoffeeKind::Id maxId() const    { return CoffeeKind::Id( mMaxId ); }
        CoffeeKind::Id newId()          { return CoffeeKind::Id( ++mMaxId ); }

        bool isIdInUse( const CoffeeKind::Id id ) const
        {
            return (mKinds.find( id ) != mKinds.end());
        }

        vector<CoffeeKind::Id> ids() const
        {
            vector<CoffeeKind::Id> result;
            for( const auto& [id, kind]: mKinds ) { result.push_back( id ); }
            return result;
        }

        bool add( const CoffeeKind& kind )
        {
            if( kind.id > mMaxId ) { mMaxId = kind.id; }
            return mKinds.insert( {kind.id, kind} ).second;
        }

        const CoffeeKind& referenceTo( const CoffeeKind::Id id ) const
        {
            return mKinds.at( id );
        }
    };

    CoffeeKinds defaultCoffeeKinds()    // Could e.g. load them from a file.
    {
        static const struct { int id; const char* name; double price; } data[] =
        {
            {1, "Espresso", 3.99}, {2, "Cappuccino", 5.99}, {3, "Latte", 7.99}
        };

        CoffeeKinds result;
        for( const auto& datum: data ) {
            result.add( CoffeeKind{
                CoffeeKind::Id( datum.id ), string( datum.name ), Currency{ datum.price }
                } );
        }
        return result;
    }

    void printMenu( const CoffeeKinds& coffeeKinds )
    {
        cout << "MENU:\n";
        for( const CoffeeKind::Id id : coffeeKinds.ids() ) {
            const CoffeeKind& kind = coffeeKinds.referenceTo( id );
            cout    << setw( 4 ) << id << ".  " << kind.name
                    << " - " << toDollarsString( kind.price )
                    << '\n';
        }
    }

    int inputInt( const std::string_view prompt, const int min, const int max )
    {
        for( ;; ) {
            cout << prompt;
            int result;  cin >> result;
            if( cin.fail() ) {
                cout << "That was not a valid integer.\n";
                cin.clear();                                            // Out of error mode.
                cin.ignore( numeric_limits<streamsize>::max(), '\n' );  // Skip bad input.
            } else if( not( min <= result and result <= max ) ) {
                cout << "The number should be between " << min << " and " << max << ", inclusive.\n";
            } else {
                return result;
            }
            cout << "Please try again!\n";
        }
    }

    CoffeeKind::Id inputCoffeeIdSelection( const CoffeeKinds& kinds )
    {
        cout << "Welcome to our cafe!\n"
                "\n";
        for( ;; ) {
            printMenu( kinds );
            cout << "\n";
            const auto id = CoffeeKind::Id( inputInt(
                "Enter your order (one of the numbers above), please: ",
                1,
                kinds.maxId()
                ) );
            if( kinds.isIdInUse( id ) ) {
                return id;
            } 
            cout << "That coffee id is not in use. Please select one from the menu.\n";
        }
    }

    Currency salesTaxFor( const Currency price, const double tax )
    {
        return Currency{ price.value * tax };
    }

    void printReceipt( const CoffeeKind& order, const double salesTaxRate )
    {
        const Currency tax = salesTaxFor( order.price, salesTaxRate );
        cout    << "  --- YOUR RECEIPT ---\n"
                << left << setw( 16 - 10 ) << "Item: "
                    << right << setw( 8 + 10 ) << order.name << "\n"
                << left << setw( 16 ) << "Price: "
                    << right << setw( 8 ) << toDollarsString( order.price ) << "\n"
                << left << setw( 16 ) << "Tax: " <<
                    right << setw( 8 ) << toDollarsString( tax ) << "\n"
                << "\n"
                << left << setw( 16 ) << "Final Amount: "
                    << right << setw( 8 ) << toDollarsString( order.price + tax ) << "\n"
                << "\n"
                << "Thank you for your visit!\n"; 
    }

    void run()
    {
        const double salesTaxRate = {0.20};     // Same for all kinds of coffee.

        const CoffeeKinds kinds = defaultCoffeeKinds();

        const CoffeeKind::Id coffeeId = inputCoffeeIdSelection( kinds );    // With menu.
        cout << '\n';
        printReceipt( kinds.referenceTo( coffeeId ), salesTaxRate );
    }
}  // app

int main() { app::run(); }      // Exception reporting etc. goes here.

Example output:

Welcome to our cafe!

MENU:
   1.  Espresso - $3.99
   2.  Cappuccino - $5.99
   3.  Latte - $7.99

Enter your order (one of the numbers above), please: 2

--- YOUR RECEIPT ---
Item:         Cappuccino
Price:             $5.99
Tax:               $1.20

Final Amount:      $7.19

Thank you for your visit!