Support for nuget

[freddydk]

Support for publishing successful builds to nuget and to use nuget for dependencies.
nuget is a package manager which could be used to standardize the way Business Central app dependencies are used across repositories.

[jonaswre]

This would be a better implementation from the current one the exists in DevOps. And is a must for large dependency trees.

Two advantages are that the minimum version resolution works out of the box. And secondly you get 4 digits in your version no. Which is what BC expects.

I don't think I'll find time the next few weeks but this is has been on my mind for a long time.

I have a crude example that worked locally I could upload it here. Maybe it helps.

[jonaswre]

This is my curde example I used to generate the .nuspec file.

Once the apps are build you need to create a nuspec file for each app and then pack it.
After that you can publish it to a nuget feed.

the rest is basicly handled by nuget it self. except for removing the nupkg file from the .alpackages folder. (maybe somebody knows how to exclude that)

One issue i encountered when integrating into the bccontainerhelper was that I wasn't sure if you need to have the nuget.exe or if its enough use Install-Package from Powershell.
But I guess this is not the main concern here because you have more control over the build enviroment. You can just make sure nuget is just installed normally.
But in bccontainerhelper I didn't want to introduce more external dependencies then needed. Because they will need to be installed on each client that use them. And each dependency makes installing bccontainerhelper a bit more difficult which is not great. (I realized that with the az cli. thats always a struggle if you do the first setup)

$path = "C:\Users\<user>\Desktop\output"

$XmlFilePath = "C:\Users\<user>\Desktop\PACK\.nuspec"
$nugetPath = "C:\Users\<user>\Desktop\nuget.exe"
$output = "C:\Users\<user>\Desktop"

#$telemetryScope = InitTelemetryScope -name $MyInvocation.InvocationName -parameterValues $PSBoundParameters -includeParameters @()
try {
    Get-Childitem –Path (Join-Path $path "\Apps\*.app") | % {
        $basename = $_.Basename

        $tempAppFolder = Join-Path ((Get-Item -Path $env:temp).FullName) ([Guid]::NewGuid().ToString())
        $tempAppOutFolder = Join-Path $tempAppFolder "out"
        $tempAppSourceFolder = Join-Path $tempAppFolder "source"
        try {
            New-Item -path $tempAppFolder -ItemType Directory -Force 
            New-Item -path $tempAppOutFolder -ItemType Directory -Force 
            Copy-Item -Path $_ -Destination $tempAppOutFolder
            Write-Host $tempAppFolder
            Write-Host "Processing: $basename"
     
            $runtimeApps = @(Get-Item -Path (Join-Path $path "\RuntimePackages\*$basename*"))
            if ($runtimeApps.length -eq 1) {
                $runtimeApp = $runtimeApps[0];
                Copy-Item -Path $runtimeApp -Destination $tempAppOutFolder
            }
            elseif ($runtimeApps.length -eq 0) {
                Write-Host "No runtime app found."
            }
            else {
                Write-Warning "More then one runtime app found!!!"
            }
    
              
            Extract-AppFileToFolder -appFilename (Join-Path $tempAppOutFolder $_.Name) -generateAppJson -appFolder $tempAppSourceFolder
    
            $appJson = [System.IO.File]::ReadAllLines((Join-Path $tempAppSourceFolder "app.json")) | ConvertFrom-Json
            Write-Host $appJson
            $XmlFilePath = (Join-Path $tempAppOutFolder ".nuspec")

            $encoding = [System.Text.Encoding]::UTF8
            $XmlWriter = New-Object System.XMl.XmlTextWriter($XmlFilePath,$encoding)
            $xmlWriter.Formatting = "Indented"
            $xmlWriter.Indentation = "4"
            $xmlWriter.WriteStartDocument()
            $xmlWriter.WriteStartElement("package")
            $xmlWriter.WriteAttributeString("xmlns", "http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd");

                $xmlWriter.WriteStartElement("metadata")

                    $xmlWriter.WriteStartElement("id")
                        $xmlWriter.WriteString($appJson.id);
                    $xmlWriter.WriteEndElement()

                    $xmlWriter.WriteStartElement("version")
                        $xmlWriter.WriteString($appJson.version);
                    $xmlWriter.WriteEndElement()

                    $xmlWriter.WriteStartElement("description")
                        $xmlWriter.WriteString($appJson.description);
                    $xmlWriter.WriteEndElement()

                    $xmlWriter.WriteStartElement("authors")
                        $xmlWriter.WriteString($appJson.publisher);
                    $xmlWriter.WriteEndElement()



                    if($appJson.dependencies.Count -gt 0) {

                        $xmlWriter.WriteStartElement("dependencies")

                            $appJson.dependencies | % {
                                $xmlWriter.WriteStartElement("dependency")
                                     $xmlWriter.WriteAttributeString("id", $_.id);
                                     $xmlWriter.WriteAttributeString("version", $_.version);
                                $xmlWriter.WriteEndElement()
                            }

                        $xmlWriter.WriteEndElement()
                    }

                $xmlWriter.WriteEndElement()

                $xmlWriter.WriteStartElement("files")
                    $xmlWriter.WriteStartElement("file")
                    $xmlWriter.WriteAttributeString("src", "*.app");
                    $xmlWriter.WriteEndElement()
                $xmlWriter.WriteEndElement()

            $xmlWriter.WriteEndElement()
            $xmlWriter.WriteEndDocument()
            $xmlWriter.Flush()
            $xmlWriter.Close()

            & $nugetPath pack $tempAppOutFolder -OutputDirectory $output

        }
        finally {
            Remove-Item -Path $tempAppFolder -Recurse -Force -ErrorAction SilentlyContinue
        }
    }
}
catch {
    #TrackException -telemetryScope $telemetryScope -errorRecord $_
    throw
}
finally {
    #TrackTrace -telemetryScope $telemetryScope
}

[freddydk]

Thanks, it is very nice to have this in this thread when we decide to groom this feature.

The way I think about this would not be to have individual apps as nuget packages, but the output of one project in AL-Go (which could be one app or multiple apps).

In the repo, which uses the app, you would have an appDependencyProbingPath setting, which points to the nuget package and the apps from within the package which are referenced from your app are installed and used.

This is the way AL-Go currently handles dependencies between repos (described here: https://freddysblog.com/2022/04/28/structuring-your-github-repositories/).

In AL-Go you can then set the updateDependencies setting to true and then your app will be built and tested with the downloaded dependencies - and the actual app version number from these dependencies will replace the version numbers you have in app.json.
Furthermore, you can set the generateDependencyArtifacts to copy all used dependencies to a build artifact in CI/CD.

[jonaswre]

Maybe thats something thats special on how AL-Go handles dependencies. If I understand you dont plan to integrate a package manager. You would just use nuget as a storage for dependencies. To be honest I don't see the benefit of using nuget, if you don't want to use nuget for resolution.

In my experience its generally better, specially in very very large dependency forests (20+ recursive dependencies), to have the package manager resolve the atomic dependencies.
Firstly this is how every package manager works. (Which must mean something 😆)
Secondly, if introducing new dependecies you only need to add your new dependency to your app.json. Any build up the tree will automaticlly resolve the newly added dependency. And seperation between version (release, preview) can be done using diffrend feeds.

In the way you suggested, to resolve dependecies you would basicly need to use generateDependencyArtifacts in very node of the tree so that you carry the dependencies up the tree. This would duplicate a lot of apps.

But maybe I'm missing a crucial part.

[jonaswre]

Ohh and a another benefit for atomic resolution you could resolve dependency not only from you private feed but also from other partners. This would allow a partner to release apps using a nuget feed so that everyone that wants to depend on another module can just grab the right version directly from the partners feed.

The partners feed doesn't need to be public it could be protected with read permission for people you signed contracts with.

[freddydk]

I am probably missing some knowledge about nuget and package managers:-)
I think it is great to have these disucssions here - and I will definitely ask for your input when we start designing this feature to make sure we get it right.

One of the things I want to avoid is that you have to modify version numbers in app.json all the time.
If your repo was built against a set of apps - these apps should be the minimum required app for your app.

Not sure when I get to look at this though.

[jonaswre]

I really get the wish to minimize editing the app.json as much as possible. But I think this isn't a problem. Nuget can treat the version already as minimum. So editing would only be necessary if you need new features that are not present in the minimum version you specified.

https://docs.microsoft.com/en-us/nuget/concepts/package-versioning

If I find time to create a little prototyp. I'll keep you updated here.