Refactor IPackage (#4174)

## Change
To better reflect the underlying code and continue to move business
logic out of the `CompositeSource`, this change refactors the `IPackage`
interface into 3:

```C++
    // Contains a collection of package versions.
    struct IPackageVersionCollection
    {
        // Gets all versions of this package.
        // The versions will be returned in sorted, descending order.
        //  Ex. { 4, 3, 2, 1 }
        virtual std::vector<PackageVersionKey> GetVersionKeys() const = 0;

        // Gets a specific version of this package.
        virtual std::shared_ptr<IPackageVersion> GetVersion(const PackageVersionKey& versionKey) const = 0;

        // A convenience method to effectively call `GetVersion(GetVersionKeys[0])`.
        virtual std::shared_ptr<IPackageVersion> GetLatestVersion() const = 0;
    };

    // Contains information about a package and its versions from a single source.
    struct IPackage : public IPackageVersionCollection
    {
        // Gets a property of this package.
        virtual Utility::LocIndString GetProperty(PackageProperty property) const = 0;

        // Gets the source that this package is from.
        virtual Source GetSource() const = 0;

        // Determines if the given IPackage refers to the same package as this one.
        virtual bool IsSame(const IPackage*) const = 0;

        // Gets this object as the requested type, or null if it is not the requested type.
        virtual const void* CastTo(IPackageType type) const = 0;
    };

    // Contains information about the graph of packages related to a search.
    struct ICompositePackage
    {
        // Gets a property of this package result.
        virtual Utility::LocIndString GetProperty(PackageProperty property) const = 0;

        // Gets the installed package information.
        virtual std::shared_ptr<IPackage> GetInstalled() = 0;

        // Gets all of the available packages for this result.
        // There will be at most one package per source in this list.
        virtual std::vector<std::shared_ptr<IPackage>> GetAvailable() = 0;
    };
```

`IPackageVersionCollection` is simply a set of `IPackageVersion` objects
with only the previous `IPackage` functions to enumerate them. This
enables some code that only wants to inspect versions to use a tighter
set of APIs and thus some implementations need not worry about things
like the appropriate property values to return.

The refactored `IPackage` inherits from `IPackageVersionCollection` and
is itself a set of package versions that all come from a single source
(as in `Source`). It adds the properties and the `Source` that the
versions are all from.

`ICompositePackage` is the new search result, resembling the previous
`IPackage` in what it contains but exposing it more directly. The
installed `IPackage` object will eventually be able to contain more than
one installed version in a future change. The available packages are
exposed directly as `IPackage` objects, rather than mixing the versions
together in the `CompositeSource`.

The code in `PackageVersionSelection.cpp` extracts the business logic
that was inside `CompositeSource` previously, as well as providing a few
helpers to make the existing code work more succinctly. The refactoring
is not attempting to change behavior, but simply make it possible to
change behavior more easily and precisely in the future.

I would have preferred to go further by splitting `CompositeSource` out
into a public type, allowing the other sources to have a simpler model
of only ever returning `IPackage` results from search. This change would
have created an even larger churn though and did not directly contribute
towards the goal of supporting future side-by-side work.
  
Also changes the YAML object model to use a non-exceptional function to
attempt to convert to an integer.

Author: JohnMcPMS

src/AppInstallerCLICore/ConfigurationWingetDscModuleUnitValidation.cpp

@@ -358,7 +358,8 @@ namespace AppInstaller::CLI::Configuration
                    {
                        if (!package.Version.empty())
                        {
-                           auto versionKeys = searchResult.Matches.at(0).Package->GetAvailableVersionKeys();
+                           std::shared_ptr<Repository::IPackage> availablePackage = searchResult.Matches.at(0).Package->GetAvailable().at(0);
+                           auto versionKeys = availablePackage->GetVersionKeys();
                            bool foundVersion = false;
                            for (auto const& versionKey : versionKeys)
                            {

src/AppInstallerCLICore/ExecutionContextData.h

@@ -105,7 +105,7 @@ namespace AppInstaller::CLI::Execution
         template <>
         struct DataMapping<Data::Package>
         {
-            using value_t = std::shared_ptr<Repository::IPackage>;
+            using value_t = std::shared_ptr<Repository::ICompositePackage>;
         };
 
         template <>

src/AppInstallerCLICore/Workflows/CompletionFlow.cpp

@@ -70,11 +70,14 @@ namespace AppInstaller::CLI::Workflow
         const std::string& word = context.Get<Data::CompletionData>().Word();
         auto stream = context.Reporter.Completion();
 
-        for (const auto& vc : context.Get<Execution::Data::Package>()->GetAvailableVersionKeys())
+        for (const auto& ap : context.Get<Execution::Data::Package>()->GetAvailable())
         {
-            if (word.empty() || Utility::ICUCaseInsensitiveStartsWith(vc.Version, word))
+            for (const auto& vc : ap->GetVersionKeys())
             {
-                OutputCompletionString(stream, vc.Version);
+                if (word.empty() || Utility::ICUCaseInsensitiveStartsWith(vc.Version, word))
+                {
+                    OutputCompletionString(stream, vc.Version);
+                }
             }
         }
     }
@@ -86,12 +89,15 @@ namespace AppInstaller::CLI::Workflow
 
         std::vector<std::string> channels;
 
-        for (const auto& vc : context.Get<Execution::Data::Package>()->GetAvailableVersionKeys())
+        for (const auto& ap : context.Get<Execution::Data::Package>()->GetAvailable())
         {
-            if ((word.empty() || Utility::ICUCaseInsensitiveStartsWith(vc.Channel, word)) &&
-                std::find(channels.begin(), channels.end(), vc.Channel) == channels.end())
+            for (const auto& vc : ap->GetVersionKeys())
             {
-                channels.emplace_back(vc.Channel);
+                if ((word.empty() || Utility::ICUCaseInsensitiveStartsWith(vc.Channel, word)) &&
+                    std::find(channels.begin(), channels.end(), vc.Channel) == channels.end())
+                {
+                    channels.emplace_back(vc.Channel);
+                }
             }
         }
 

src/AppInstallerCLICore/Workflows/DependencyNodeProcessor.cpp

@@ -4,6 +4,7 @@
 #include "DependencyNodeProcessor.h"
 #include "ManifestComparator.h"
 #include <winget/PinningData.h>
+#include <winget/PackageVersionSelection.h>
 
 using namespace AppInstaller::Manifest;
 using namespace AppInstaller::Repository;
@@ -41,20 +42,21 @@ namespace AppInstaller::CLI::Workflow
         const auto& match = matches.at(0);
         const auto& package = match.Package;
         auto packageId = package->GetProperty(PackageProperty::Id);
-        m_nodePackageInstalledVersion = package->GetInstalledVersion();
+        m_nodePackageInstalledVersion = GetInstalledVersion(package);
+        std::shared_ptr<IPackageVersionCollection> availableVersions = GetAvailableVersionsForInstalledVersion(package);
 
         if (m_context.Args.Contains(Execution::Args::Type::Force))
         {
-            m_nodePackageLatestVersion = package->GetLatestAvailableVersion();
+            m_nodePackageLatestVersion = availableVersions->GetLatestVersion();
         }
         else
         {
             Pinning::PinBehavior pinBehavior = m_context.Args.Contains(Execution::Args::Type::IncludePinned) ? Pinning::PinBehavior::IncludePinned : Pinning::PinBehavior::ConsiderPins;
 
             Pinning::PinningData pinningData{ Pinning::PinningData::Disposition::ReadOnly };
-            auto evaluator = pinningData.CreatePinStateEvaluator(pinBehavior, package->GetInstalledVersion());
+            auto evaluator = pinningData.CreatePinStateEvaluator(pinBehavior, m_nodePackageInstalledVersion);
 
-            m_nodePackageLatestVersion = evaluator.GetLatestAvailableVersionForPins(package);
+            m_nodePackageLatestVersion = evaluator.GetLatestAvailableVersionForPins(availableVersions);
         }
 
         if (m_nodePackageInstalledVersion && dependencyNode.IsVersionOk(Utility::Version(m_nodePackageInstalledVersion->GetProperty(PackageVersionProperty::Version))))

src/AppInstallerCLICore/Workflows/ImportExportFlow.cpp

@@ -9,6 +9,7 @@
 #include "WorkflowBase.h"
 #include <winget/RepositorySearch.h>
 #include <winget/Runtime.h>
+#include <winget/PackageVersionSelection.h>
 
 namespace AppInstaller::CLI::Workflow
 {
@@ -60,20 +61,22 @@ namespace AppInstaller::CLI::Workflow
         // If requested, checks that the installed version is available and reports a warning if it is not.
         std::shared_ptr<IPackageVersion> GetAvailableVersionForInstalledPackage(
             Execution::Context& context,
-            std::shared_ptr<IPackage> package,
+            std::shared_ptr<ICompositePackage> package,
             Utility::LocIndView version,
             Utility::LocIndView channel,
             bool checkVersion)
         {
+            std::shared_ptr<IPackageVersionCollection> availableVersions = GetAvailableVersionsForInstalledVersion(package);
+
             if (!checkVersion)
             {
-                return package->GetLatestAvailableVersion();
+                return availableVersions->GetLatestVersion();
             }
 
-            auto availablePackageVersion = package->GetAvailableVersion({ "", version, channel });
+            auto availablePackageVersion = availableVersions->GetVersion({ "", version, channel });
             if (!availablePackageVersion)
             {
-                availablePackageVersion = package->GetLatestAvailableVersion();
+                availablePackageVersion = availableVersions->GetLatestVersion();
                 if (availablePackageVersion)
                 {
                     // Warn installed version is not available.
@@ -100,7 +103,7 @@ namespace AppInstaller::CLI::Workflow
         auto& exportedSources = exportedPackages.Sources;
         for (const auto& packageMatch : searchResult.Matches)
         {
-            auto installedPackageVersion = packageMatch.Package->GetInstalledVersion();
+            auto installedPackageVersion = GetInstalledVersion(packageMatch.Package);
             auto version = installedPackageVersion->GetProperty(PackageVersionProperty::Version);
             auto channel = installedPackageVersion->GetProperty(PackageVersionProperty::Channel);
 

src/AppInstallerCLICore/Workflows/PinFlow.cpp

@@ -6,6 +6,7 @@
 #include "TableOutput.h"
 #include <winget/PinningData.h>
 #include <winget/RepositorySearch.h>
+#include <winget/PackageVersionSelection.h>
 
 using namespace AppInstaller::Repository;
 
@@ -38,21 +39,20 @@ namespace AppInstaller::CLI::Workflow
 
             if (context.Args.Contains(Execution::Args::Type::PinInstalled))
             {
-                auto installedVersion = package->GetInstalledVersion();
+                auto installedVersion = GetInstalledVersion(package);
                 if (installedVersion)
                 {
                     pinKeys.emplace(Pinning::PinKey::GetPinKeyForInstalled(installedVersion->GetProperty(PackageVersionProperty::Id)));
                 }
             }
             else
             {
-                auto packageVersionKeys = package->GetAvailableVersionKeys();
-                for (const auto& versionKey : packageVersionKeys)
+                auto availablePackages = package->GetAvailable();
+                for (const auto& availablePackage : availablePackages)
                 {
-                    auto availableVersion = package->GetAvailableVersion(versionKey);
                     pinKeys.emplace(
-                        availableVersion->GetProperty(PackageVersionProperty::Id).get(),
-                        availableVersion->GetProperty(PackageVersionProperty::SourceIdentifier).get());
+                        availablePackage->GetProperty(PackageProperty::Id).get(),
+                        availablePackage->GetSource().GetIdentifier());
                 }
             }
 
@@ -140,7 +140,7 @@ namespace AppInstaller::CLI::Workflow
                 }
                 else
                 {
-                    auto availableVersion = package->GetAvailableVersion({ pinKey.SourceId, "", "" });
+                    auto availableVersion = GetAvailablePackageFromSource(package, pinKey.SourceId)->GetLatestVersion();
                     if (availableVersion)
                     {
                         packageNameToReport = availableVersion->GetProperty(PackageVersionProperty::Name);
@@ -198,8 +198,6 @@ namespace AppInstaller::CLI::Workflow
         // Note that if a source was specified in the command line,
         // that will be the only one we get version keys from.
         // So, we remove pins from all sources unless one was provided.
-        auto packageVersionKeys = package->GetAvailableVersionKeys();
-
         for (const auto& pin : pins)
         {
             AICLI_LOG(CLI, Info, << "Removing Pin " << pin.GetKey().ToString());
@@ -255,15 +253,19 @@ namespace AppInstaller::CLI::Workflow
                 else
                 {
                     // This ensures we get the info from the right source if it exists on multiple
-                    auto availableVersion = match.Package->GetAvailableVersion({ pinKey.SourceId, "", "" });
-                    if (availableVersion)
+                    auto availablePackage = GetAvailablePackageFromSource(match.Package, pinKey.SourceId);
+                    if (availablePackage)
                     {
-                        packageName = availableVersion->GetProperty(PackageVersionProperty::Name);
-                        sourceName = availableVersion->GetProperty(PackageVersionProperty::SourceName);
+                        auto availableVersion = availablePackage->GetLatestVersion();
+                        if (availableVersion)
+                        {
+                            packageName = availableVersion->GetProperty(PackageVersionProperty::Name);
+                            sourceName = availableVersion->GetProperty(PackageVersionProperty::SourceName);
+                        }
                     }
                 }
 
-                auto installedVersion = match.Package->GetInstalledVersion();
+                auto installedVersion = GetInstalledVersion(match.Package);
                 if (installedVersion)
                 {
                     packageName = installedVersion->GetProperty(PackageVersionProperty::Name);

src/AppInstallerCLICore/Workflows/RepairFlow.cpp

@@ -14,6 +14,7 @@
 #include "AppInstallerSynchronization.h"
 #include "MSStoreInstallerHandler.h"
 #include "ManifestComparator.h"
+#include <winget/PackageVersionSelection.h>
 
 using namespace AppInstaller::Manifest;
 using namespace AppInstaller::Msix;
@@ -443,10 +444,11 @@ namespace AppInstaller::CLI::Workflow
         std::string_view requestedVersion = context.Args.Contains(Execution::Args::Type::Version) ? context.Args.GetArg(Execution::Args::Type::Version) : installedVersion.ToString();
         // If it's Store source with only one version unknown, use the unknown version for available version mapping.
         const auto& package = context.Get<Execution::Data::Package>();
-        auto versionKeys = package->GetAvailableVersionKeys();
+        auto packageVersions = GetAvailableVersionsForInstalledVersion(package, installedPackage);
+        auto versionKeys = packageVersions->GetVersionKeys();
         if (versionKeys.size() == 1)
         {
-            auto packageVersion = package->GetAvailableVersion(versionKeys.at(0));
+            auto packageVersion = packageVersions->GetVersion(versionKeys.at(0));
             if (packageVersion->GetSource().IsWellKnownSource(WellKnownSource::MicrosoftStore) &&
                 Utility::Version{ packageVersion->GetProperty(PackageVersionProperty::Version) }.IsUnknown())
             {

src/AppInstallerCLICore/Workflows/UninstallFlow.cpp

@@ -11,6 +11,7 @@
 #include <AppInstallerDeployment.h>
 #include <AppInstallerSynchronization.h>
 #include <winget/Runtime.h>
+#include <winget/PackageVersionSelection.h>
 
 using namespace AppInstaller::CLI::Execution;
 using namespace AppInstaller::Manifest;
@@ -34,9 +35,8 @@ namespace AppInstaller::CLI::Workflow
                 std::string SourceIdentifier;
             };
 
-            void AddIfRemoteAndNotPresent(const std::shared_ptr<IPackageVersion>& packageVersion)
+            void AddIfRemoteAndNotPresent(Source&& source, const Utility::LocIndString& identifier)
             {
-                auto source = packageVersion->GetSource();
                 const auto details = source.GetDetails();
                 if (!source.ContainsAvailablePackages())
                 {
@@ -51,7 +51,17 @@ namespace AppInstaller::CLI::Workflow
                     }
                 }
 
-                Items.emplace_back(Item{ packageVersion->GetProperty(PackageVersionProperty::Id), std::move(source), details.Identifier });
+                Items.emplace_back(Item{ identifier, std::move(source), details.Identifier });
+            }
+
+            void AddIfRemoteAndNotPresent(const std::shared_ptr<IPackageVersion>& packageVersion)
+            {
+                AddIfRemoteAndNotPresent(packageVersion->GetSource(), packageVersion->GetProperty(PackageVersionProperty::Id));
+            }
+
+            void AddIfRemoteAndNotPresent(const std::shared_ptr<IPackage>& package)
+            {
+                AddIfRemoteAndNotPresent(package->GetSource(), package->GetProperty(PackageProperty::Id));
             }
 
             std::vector<Item> Items;
@@ -311,12 +321,12 @@ namespace AppInstaller::CLI::Workflow
         UninstallCorrelatedSources correlatedSources;
 
         // Start with the installed version
-        correlatedSources.AddIfRemoteAndNotPresent(package->GetInstalledVersion());
+        correlatedSources.AddIfRemoteAndNotPresent(GetInstalledVersion(package));
 
         // Then look through all available versions
-        for (const auto& versionKey : package->GetAvailableVersionKeys())
+        for (const auto& availablePackage : package->GetAvailable())
         {
-            correlatedSources.AddIfRemoteAndNotPresent(package->GetAvailableVersion(versionKey));
+            correlatedSources.AddIfRemoteAndNotPresent(availablePackage);
         }
 
         // Finally record the uninstall for each found value

src/AppInstallerCLICore/Workflows/UpdateFlow.cpp

@@ -1,13 +1,13 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
-
 #include "pch.h"
 #include "WorkflowBase.h"
 #include "DependenciesFlow.h"
 #include "InstallFlow.h"
 #include "UpdateFlow.h"
 #include "ManifestComparator.h"
 #include <winget/PinningData.h>
+#include <winget/PackageVersionSelection.h>
 
 using namespace AppInstaller::Repository;
 using namespace AppInstaller::Repository::Microsoft;
@@ -72,10 +72,11 @@ namespace AppInstaller::CLI::Workflow
         const bool includePinned = m_isSinglePackage || context.Args.Contains(Execution::Args::Type::IncludePinned);
 
         PinningData pinningData{ PinningData::Disposition::ReadOnly };
-        auto evaluator = pinningData.CreatePinStateEvaluator(includePinned ? PinBehavior::IncludePinned : PinBehavior::ConsiderPins, package->GetInstalledVersion());
+        auto evaluator = pinningData.CreatePinStateEvaluator(includePinned ? PinBehavior::IncludePinned : PinBehavior::ConsiderPins, GetInstalledVersion(package));
 
         // The version keys should have already been sorted by version
-        const auto& versionKeys = package->GetAvailableVersionKeys();
+        auto availableVersions = GetAvailableVersionsForInstalledVersion(package);
+        const auto& versionKeys = availableVersions->GetVersionKeys();
         // Assume that no update versions are applicable
         bool upgradeVersionAvailable = false;
         for (const auto& key : versionKeys)
@@ -89,7 +90,7 @@ namespace AppInstaller::CLI::Workflow
                     upgradeVersionAvailable = true;
                 }
 
-                auto packageVersion = package->GetAvailableVersion(key);
+                auto packageVersion = availableVersions->GetVersion(key);
 
                 // Check if the package is pinned
                 PinType pinType = evaluator.EvaluatePinType(packageVersion);
@@ -217,7 +218,7 @@ namespace AppInstaller::CLI::Workflow
             auto updateContextPtr = context.CreateSubContext();
             Execution::Context& updateContext = *updateContextPtr;
             auto previousThreadGlobals = updateContext.SetForCurrentThread();
-            auto installedVersion = match.Package->GetInstalledVersion();
+            auto installedVersion = GetInstalledVersion(match.Package);
 
             updateContext.Add<Execution::Data::Package>(match.Package);