Skip to content

Add ATS pipeline parity for polyglot AppHosts #15826

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
sebastienros merged 11 commits into from
Apr 13, 2026
Merged

Add ATS pipeline parity for polyglot AppHosts #15826

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
11 commits
Select commit Hold shift + click to select a range
9d10ab8
Add ATS pipeline parity for polyglot AppHosts
sebastienros Apr 2, 2026
a2794b9
Fix polyglot codegen snapshot EOFs
sebastienros Apr 2, 2026
b9467c3
Simplify callback close generation
sebastienros Apr 2, 2026
87bb2f6
Merge remote-tracking branch 'origin/main' into sebros/ts-builder-pip…
sebastienros Apr 4, 2026
68fec9e
Fix redundant ATS export IDs after mainline sync
sebastienros Apr 4, 2026
0b97781
Remove redundant AppContainers export ID
sebastienros Apr 4, 2026
1484b39
Merge origin/main after AppContainers export fix
sebastienros Apr 4, 2026
4fbb50d
Merge origin/main - resolve snapshot conflict
davidfowl Apr 11, 2026
8f1d7b8
Merge remote-tracking branch 'origin/main' into sebros/ts-builder-pip…
sebastienros Apr 13, 2026
b0353f5
Sync latest main and harden StartStop E2E
sebastienros Apr 13, 2026
cbf92f9
Harden remaining StartStop E2E waits
sebastienros Apr 13, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
55 changes: 28 additions & 27 deletions src/Aspire.Hosting.CodeGeneration.TypeScript/AtsTypeScriptCodeGenerator.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1337,7 +1337,6 @@ private void GenerateTypeClassInterface(BuilderModel model)
{
var className = DeriveClassName(model.TypeId);
var interfaceName = GetInterfaceName(className);
var hasMethods = HasChainableMethods(model);

WriteLine("// ============================================================================");
WriteLine($"// {interfaceName}");
Expand All @@ -1350,14 +1349,16 @@ private void GenerateTypeClassInterface(BuilderModel model)
var setters = model.Capabilities.Where(c => c.CapabilityKind == AtsCapabilityKind.PropertySetter).ToList();
var contextMethods = model.Capabilities.Where(c => c.CapabilityKind == AtsCapabilityKind.InstanceMethod).ToList();
var otherMethods = model.Capabilities.Where(c => c.CapabilityKind == AtsCapabilityKind.Method).ToList();
var standardMethods = contextMethods.Concat(otherMethods).ToList();
var hasMethods = standardMethods.Count > 0;

var properties = GroupPropertiesByName(getters, setters);
foreach (var prop in properties)
{
GenerateInterfaceProperty(prop.PropertyName, prop.Getter, prop.Setter);
}

foreach (var method in contextMethods.Concat(otherMethods))
foreach (var method in standardMethods)
{
GenerateTypeClassInterfaceMethod(className, method);
}
Expand All @@ -1372,7 +1373,7 @@ private void GenerateTypeClassInterface(BuilderModel model)

var promiseInterfaceName = GetPromiseInterfaceName(className);
WriteLine($"export interface {promiseInterfaceName} extends PromiseLike<{interfaceName}> {{");
foreach (var method in contextMethods.Concat(otherMethods))
foreach (var method in standardMethods)
{
GenerateTypeClassInterfaceMethod(className, method);
}
Expand Down Expand Up @@ -1776,7 +1777,8 @@ private void GenerateResolveAndBuildArgs(
private void GenerateArgsObjectWithConditionals(
string targetParamName,
List<AtsParameterInfo> requiredParams,
List<AtsParameterInfo> optionalParams)
List<AtsParameterInfo> optionalParams,
string indent = " ")
Comment thread
sebastienros marked this conversation as resolved.
{
// Build the required args inline
var requiredArgs = new List<string> { $"{targetParamName}: this._handle" };
Expand All @@ -1785,13 +1787,13 @@ private void GenerateArgsObjectWithConditionals(
requiredArgs.Add(GetRpcArgumentEntry(param));
}

WriteLine($" const rpcArgs: Record<string, unknown> = {{ {string.Join(", ", requiredArgs)} }};");
WriteLine($"{indent}const rpcArgs: Record<string, unknown> = {{ {string.Join(", ", requiredArgs)} }};");

// Conditionally add optional params
foreach (var param in optionalParams)
{
var rpcExpression = GetRpcArgumentExpression(param);
WriteLine($" if ({param.Name} !== undefined) rpcArgs.{param.Name} = {rpcExpression};");
WriteLine($"{indent}if ({param.Name} !== undefined) rpcArgs.{param.Name} = {rpcExpression};");
}
}

Expand Down Expand Up @@ -2117,7 +2119,7 @@ private string GenerateCallbackTypeSignature(IReadOnlyList<AtsCallbackParameterI
return $"({paramsString}) => Promise<{returnType}>";
}

private void GenerateCallbackRegistration(AtsParameterInfo callbackParam)
private void GenerateCallbackRegistration(AtsParameterInfo callbackParam, string indent = " ")
{
var callbackParameters = callbackParam.CallbackParameters;
var isOptional = callbackParam.IsOptional || callbackParam.IsNullable;
Expand All @@ -2141,33 +2143,34 @@ private void GenerateCallbackRegistration(AtsParameterInfo callbackParam)
// For optional callbacks, wrap the registration in a conditional
if (isOptional)
{
WriteLine($" const {callbackName}Id = {callbackName} ? registerCallback(async ({paramSignature}) => {{");
WriteLine($"{indent}const {callbackName}Id = {callbackName} ? registerCallback(async ({paramSignature}) => {{");
}
else
{
WriteLine($" const {callbackName}Id = registerCallback(async ({paramSignature}) => {{");
WriteLine($"{indent}const {callbackName}Id = registerCallback(async ({paramSignature}) => {{");
}

// Generate the callback body
GenerateCallbackBody(callbackParam, callbackParameters);
GenerateCallbackBody(callbackParam, callbackParameters, indent);

// Close the callback registration
if (isOptional)
{
WriteLine(" }) : undefined;");
WriteLine(indent + "}) : undefined;");
}
Comment thread
sebastienros marked this conversation as resolved.
else
{
WriteLine(" });");
WriteLine(indent + "});");
}
Comment thread
sebastienros marked this conversation as resolved.
}

/// <summary>
/// Generates the body of a callback function.
/// </summary>
private void GenerateCallbackBody(AtsParameterInfo callbackParam, IReadOnlyList<AtsCallbackParameterInfo>? callbackParameters)
private void GenerateCallbackBody(AtsParameterInfo callbackParam, IReadOnlyList<AtsCallbackParameterInfo>? callbackParameters, string indent)
{
var callbackName = callbackParam.Name;
var bodyIndent = $"{indent} ";

// Check if callback has a return type - if so, we need to return the value
var hasReturnType = callbackParam.CallbackReturnType != null
Expand All @@ -2177,7 +2180,7 @@ private void GenerateCallbackBody(AtsParameterInfo callbackParam, IReadOnlyList<
if (callbackParameters is null || callbackParameters.Count == 0)
{
// No parameters - just call the callback
WriteLine($" {returnPrefix}await {callbackName}();");
WriteLine($"{bodyIndent}{returnPrefix}await {callbackName}();");
}
else if (callbackParameters.Count == 1)
{
Expand All @@ -2188,22 +2191,22 @@ private void GenerateCallbackBody(AtsParameterInfo callbackParam, IReadOnlyList<

if (cbTypeId == AtsConstants.CancellationToken)
{
WriteLine($" const {cbParam.Name} = CancellationToken.fromValue({cbParam.Name}Data);");
WriteLine($"{bodyIndent}const {cbParam.Name} = CancellationToken.fromValue({cbParam.Name}Data);");
}
else if (_wrapperClassNames.TryGetValue(cbTypeId, out var wrapperClassName))
{
// For types with wrapper classes, create an instance of the wrapper
var handleType = GetHandleTypeName(cbTypeId);
WriteLine($" const {cbParam.Name}Handle = wrapIfHandle({cbParam.Name}Data) as {handleType};");
WriteLine($" const {cbParam.Name} = new {GetImplementationClassName(wrapperClassName)}({cbParam.Name}Handle, this._client);");
WriteLine($"{bodyIndent}const {cbParam.Name}Handle = wrapIfHandle({cbParam.Name}Data) as {handleType};");
WriteLine($"{bodyIndent}const {cbParam.Name} = new {GetImplementationClassName(wrapperClassName)}({cbParam.Name}Handle, this._client);");
}
else
{
// For raw handle types, just wrap and cast
WriteLine($" const {cbParam.Name} = wrapIfHandle({cbParam.Name}Data) as {tsType};");
WriteLine($"{bodyIndent}const {cbParam.Name} = wrapIfHandle({cbParam.Name}Data) as {tsType};");
}

WriteLine($" {returnPrefix}await {callbackName}({cbParam.Name});");
WriteLine($"{bodyIndent}{returnPrefix}await {callbackName}({cbParam.Name});");
}
else
{
Expand All @@ -2217,24 +2220,24 @@ private void GenerateCallbackBody(AtsParameterInfo callbackParam, IReadOnlyList<

if (cbTypeId == AtsConstants.CancellationToken)
{
WriteLine($" const {cbParam.Name} = CancellationToken.fromValue(args.p{i});");
WriteLine($"{bodyIndent}const {cbParam.Name} = CancellationToken.fromValue({callbackArgName});");
}
else if (_wrapperClassNames.TryGetValue(cbTypeId, out var wrapperClassName))
{
// For types with wrapper classes, create an instance of the wrapper
var handleType = GetHandleTypeName(cbTypeId);
WriteLine($" const {cbParam.Name}Handle = wrapIfHandle({callbackArgName}) as {handleType};");
WriteLine($" const {cbParam.Name} = new {GetImplementationClassName(wrapperClassName)}({cbParam.Name}Handle, this._client);");
WriteLine($"{bodyIndent}const {cbParam.Name}Handle = wrapIfHandle({callbackArgName}) as {handleType};");
WriteLine($"{bodyIndent}const {cbParam.Name} = new {GetImplementationClassName(wrapperClassName)}({cbParam.Name}Handle, this._client);");
}
else
{
// For raw handle types, just wrap and cast
WriteLine($" const {cbParam.Name} = wrapIfHandle({callbackArgName}) as {tsType};");
WriteLine($"{bodyIndent}const {cbParam.Name} = wrapIfHandle({callbackArgName}) as {tsType};");
}
callArgs.Add(cbParam.Name);
}

WriteLine($" {returnPrefix}await {callbackName}({string.Join(", ", callArgs)});");
WriteLine($"{bodyIndent}{returnPrefix}await {callbackName}({string.Join(", ", callArgs)});");
}
}

Expand Down Expand Up @@ -2417,7 +2420,6 @@ private void GenerateTypeClass(BuilderModel model)
var handleType = GetHandleTypeName(model.TypeId);
var className = DeriveClassName(model.TypeId);
var implementationClassName = GetImplementationClassName(className);
var hasMethods = HasChainableMethods(model);

GenerateTypeClassInterface(model);

Expand All @@ -2431,9 +2433,8 @@ private void GenerateTypeClass(BuilderModel model)
var setters = model.Capabilities.Where(c => c.CapabilityKind == AtsCapabilityKind.PropertySetter).ToList();
var contextMethods = model.Capabilities.Where(c => c.CapabilityKind == AtsCapabilityKind.InstanceMethod).ToList();
var otherMethods = model.Capabilities.Where(c => c.CapabilityKind == AtsCapabilityKind.Method).ToList();

// Combine methods for thenable generation
var allMethods = contextMethods.Concat(otherMethods).ToList();
var hasMethods = allMethods.Count > 0;

WriteLine($"/**");
WriteLine($" * Type class for {className}.");
Expand Down
1 change: 1 addition & 0 deletions src/Aspire.Hosting/Ats/AtsTypeMappings.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -19,6 +19,7 @@

// Core types (from Aspire.Hosting namespace)
[assembly: AspireExport(typeof(IDistributedApplicationBuilder))]
[assembly: AspireExport(typeof(IDistributedApplicationPipeline))]
[assembly: AspireExport(typeof(DistributedApplication))]

// Note: DistributedApplicationExecutionContext has [AspireExport(ExposeProperties = true)] on the type itself
Expand Down
39 changes: 39 additions & 0 deletions src/Aspire.Hosting/Ats/PipelineExports.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -13,6 +13,45 @@ namespace Aspire.Hosting.Ats;
/// </summary>
internal static class PipelineExports
{
/// <summary>
/// Adds an application-level pipeline step in a TypeScript-friendly shape.
/// </summary>
/// <param name="pipeline">The distributed application pipeline.</param>
/// <param name="stepName">The unique name of the pipeline step.</param>
/// <param name="callback">The callback to execute when the step runs.</param>
/// <param name="dependsOn">Optional step names that this step depends on.</param>
/// <param name="requiredBy">Optional step names that require this step.</param>
[AspireExport(Description = "Adds a pipeline step to the application")]
public static void AddStep(
this global::Aspire.Hosting.Pipelines.IDistributedApplicationPipeline pipeline,
Comment thread
sebastienros marked this conversation as resolved.
string stepName,
Func<PipelineStepContext, Task> callback,
string[]? dependsOn = null,
string[]? requiredBy = null)
{
ArgumentNullException.ThrowIfNull(pipeline);
ArgumentException.ThrowIfNullOrEmpty(stepName);
ArgumentNullException.ThrowIfNull(callback);

pipeline.AddStep(stepName, callback, dependsOn, requiredBy);
}

/// <summary>
/// Registers a pipeline configuration callback in a TypeScript-friendly shape.
/// </summary>
/// <param name="pipeline">The distributed application pipeline.</param>
/// <param name="callback">The callback to execute during pipeline configuration.</param>
[AspireExport(Description = "Configures the application pipeline via a callback")]
public static void Configure(
this global::Aspire.Hosting.Pipelines.IDistributedApplicationPipeline pipeline,
Func<PipelineConfigurationContext, Task> callback)
{
ArgumentNullException.ThrowIfNull(pipeline);
ArgumentNullException.ThrowIfNull(callback);

pipeline.AddPipelineConfiguration(callback);
}

/// <summary>
/// Adds a key-value pair to the pipeline summary with a Markdown-formatted value.
/// </summary>
Expand Down
1 change: 1 addition & 0 deletions src/Aspire.Hosting/Publishing/ManifestPublishingExtensions.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -21,6 +21,7 @@ internal static class ManifestPublishingExtensions
/// </summary>
/// <param name="pipeline">The pipeline to add the manifest publishing step to.</param>
/// <returns>The pipeline for chaining.</returns>
[AspireExportIgnore(Reason = "Manifest publishing is an internal pipeline step and not part of the polyglot AppHost surface.")]
public static IDistributedApplicationPipeline AddManifestPublishing(this IDistributedApplicationPipeline pipeline)
{
var step = new PipelineStep
Expand Down
37 changes: 18 additions & 19 deletions tests/Aspire.Cli.EndToEnd.Tests/StartStopTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -49,13 +49,11 @@ public async Task CreateStartAndStopAspireProject()
// Start the AppHost in the background using aspire start
await auto.TypeAsync("aspire start");
await auto.EnterAsync();
await auto.WaitUntilTextAsync(RunCommandStrings.AppHostStartedSuccessfully, timeout: TimeSpan.FromMinutes(3));
await auto.WaitForSuccessPromptAsync(counter);

// Stop the AppHost using aspire stop
await auto.TypeAsync("aspire stop");
await auto.EnterAsync();
await auto.WaitUntilTextAsync(StopCommandStrings.AppHostStoppedSuccessfully, timeout: TimeSpan.FromMinutes(1));
await auto.WaitForSuccessPromptAsync(counter);

await auto.ClearScreenAsync(counter);
Expand Down Expand Up @@ -94,7 +92,6 @@ public async Task StopWithNoRunningAppHostExitsSuccessfully()
// Run aspire stop with no running AppHost - should exit with code 0
await auto.TypeAsync("aspire stop");
await auto.EnterAsync();
await auto.WaitUntilTextAsync(SharedCommandStrings.AppHostNotRunning, timeout: TimeSpan.FromSeconds(30));
await auto.WaitForSuccessPromptAsync(counter);

// Exit the shell
Expand Down Expand Up @@ -136,7 +133,6 @@ public async Task AddPackageWhileAppHostRunningDetached()
// Start the AppHost in detached mode (locks the project file)
await auto.TypeAsync("aspire start");
await auto.EnterAsync();
await auto.WaitUntilTextAsync(RunCommandStrings.AppHostStartedSuccessfully, timeout: TimeSpan.FromMinutes(3));
await auto.WaitForSuccessPromptAsync(counter);

// Add a package while the AppHost is running - this should auto-stop the
Expand All @@ -148,14 +144,11 @@ public async Task AddPackageWhileAppHostRunningDetached()
await auto.WaitForSuccessPromptAsync(counter);

// Clean up: stop if still running (the add command may have stopped it)
// aspire stop may return a non-zero exit code if no instances are found
// (already stopped by aspire add), so wait for known output patterns.
// aspire stop should return successfully whether the app host is still running
// or was already stopped by the preceding add command.
await auto.TypeAsync("aspire stop");
await auto.EnterAsync();
await auto.WaitUntilAsync(s =>
s.ContainsText(SharedCommandStrings.AppHostNotRunning) || s.ContainsText(StopCommandStrings.AppHostStoppedSuccessfully),
timeout: TimeSpan.FromMinutes(1), description: "AppHost stopped or no running AppHost");
await auto.WaitForAnyPromptAsync(counter);
await auto.WaitForSuccessPromptAsync(counter, timeout: TimeSpan.FromMinutes(1));

// Exit the shell
await auto.TypeAsync("exit");
Expand Down Expand Up @@ -196,7 +189,6 @@ public async Task AddPackageInteractiveWhileAppHostRunningDetached()
// Start the AppHost in detached mode (locks the project file)
await auto.TypeAsync("aspire start");
await auto.EnterAsync();
await auto.WaitUntilTextAsync(RunCommandStrings.AppHostStartedSuccessfully, timeout: TimeSpan.FromMinutes(3));
await auto.WaitForSuccessPromptAsync(counter);

// Run aspire add interactively (no integration argument) while AppHost is running.
Expand All @@ -207,20 +199,27 @@ public async Task AddPackageInteractiveWhileAppHostRunningDetached()
await auto.WaitUntilTextAsync(AddCommandStrings.SelectAnIntegrationToAdd, timeout: TimeSpan.FromMinutes(1));
await auto.TypeAsync("mongodb"); // type to filter the list
await auto.EnterAsync(); // select the filtered result
await auto.WaitUntilTextAsync("Select a version of", timeout: TimeSpan.FromSeconds(30));
await auto.EnterAsync(); // Accept the default version
var waitingForVersionSelection = false;
await auto.WaitUntilAsync(snapshot =>
{
waitingForVersionSelection = snapshot.ContainsText("Select a version of");
return waitingForVersionSelection || snapshot.ContainsText("was added successfully.");
}, timeout: TimeSpan.FromSeconds(30), description: "version prompt or add success");

if (waitingForVersionSelection)
{
await auto.EnterAsync(); // Accept the default version
}

await auto.WaitUntilTextAsync("was added successfully.", timeout: TimeSpan.FromMinutes(2));
await auto.WaitForSuccessPromptAsync(counter);

// Clean up: stop if still running
// aspire stop may return a non-zero exit code if no instances are found
// (already stopped by aspire add), so wait for known output patterns.
// aspire stop should return successfully whether the app host is still running
// or was already stopped by the preceding add command.
await auto.TypeAsync("aspire stop");
await auto.EnterAsync();
await auto.WaitUntilAsync(s =>
s.ContainsText(SharedCommandStrings.AppHostNotRunning) || s.ContainsText(StopCommandStrings.AppHostStoppedSuccessfully),
timeout: TimeSpan.FromMinutes(1), description: "AppHost stopped or no running AppHost");
await auto.WaitForAnyPromptAsync(counter);
await auto.WaitForSuccessPromptAsync(counter, timeout: TimeSpan.FromMinutes(1));

// Exit the shell
await auto.TypeAsync("exit");
Expand Down
Loading
Loading