Refactor IPackage

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);