Update Integrations

Update Integration Documentation Links & API Reference Data

This skill synchronizes the integration package catalog with documentation URL mappings and generates per-package API reference schemas. It ensures every NuGet package listed in the integrations data file has a corresponding documentation link and an up-to-date API reference JSON file.

Automation note: The scheduled update-integration-data workflow (.github/workflows/update-integration-data.yml) runs this update deterministically — no agent/LLM. It executes src/frontend/scripts/update-integration-data.ps1, which runs pnpm update:all, detects "version": changes in src/frontend/src/data/aspire-integrations.json, and — only when a version actually moves — runs the C# and TypeScript API regeneration (and the twoslash bundle) before opening a PR via the Aspire bot GitHub App. You can reproduce the full flow locally with pwsh src/frontend/scripts/update-integration-data.ps1 (add -SkipRegen for a fast data-only run). Use this skill for manual or one-off runs that need judgment — for example: adding a new integration, reconciling integration-docs.json, validating release-branch feed resolution, troubleshooting a regen failure flagged by the workflow's PR, or regenerating data outside the scheduled cadence.

Overview

The automated flow also reconciles documentation mappings and runs pnpm test:unit:structured-data before API regeneration or PR creation. This uses a data-only Vitest configuration so validation does not rewrite Astro's generated assets. Mapping changes are included in the generated PR.

The aspire.dev site maintains three key data locations:

• src/frontend/src/data/aspire-integrations.json — Package metadata fetched from the configured package feeds (titles, descriptions, icons, versions, download counts).
• src/frontend/src/data/integration-docs.json — Mappings from package names to site-relative documentation URLs.
• src/frontend/src/data/pkgs/ — Per-package API reference JSON files (e.g. Aspire.Hosting.Redis.13.1.2.json) generated by the PackageJsonGenerator tool. These feed the auto-generated API reference pages at /reference/api/.
• src/frontend/src/data/ts-modules/ — Per-package TypeScript API reference JSON files (e.g. Aspire.Hosting.Redis.13.2.0.json) generated by the AtsJsonGenerator tool. These feed the auto-generated TypeScript API reference pages at /reference/api/typescript/.
• src/frontend/src/data/twoslash/aspire.d.ts — A single consolidated TypeScript declaration bundle generated from the ts-modules JSON by scripts/generate-twoslash-types.ts. Consumed by expressive-code-twoslash to provide hover tooltips for TypeScript code samples in the docs. Source-controlled — commit the diff whenever ts-modules changes.

This skill keeps the documentation mappings in sync with the package catalog and regenerates both the C# and TypeScript API reference data.

Prerequisites

• Node.js installed and available on PATH
• .NET SDK installed and available on PATH (required for the PackageJsonGenerator tool)
• PowerShell (pwsh) available on PATH (for running the generation script)
• Working directory is the repository root
• The frontend project dependencies are installed (pnpm install in src/frontend/)

Release branch package source behavior

• On main and all non-release/* branches, official Aspire packages resolve from https://api.nuget.org/v3/index.json
• On release/* branches, official packages (Aspire.*) must resolve from the branch-specific public Azure Artifacts feed instead of nuget.org
• Community Toolkit packages (CommunityToolkit.Aspire.*) always resolve from nuget.org
• The branch name in this repo is expected to match the corresponding branch in microsoft/aspire (for example release/13.2)
• The release feed name follows darc-pub-microsoft-aspire-{shortSha} where {shortSha} is the first 8 characters of the head commit SHA for the matching Aspire release branch
• The automation derives the NuGet service index from that feed name as https://pkgs.dev.azure.com/dnceng/public/_packaging/{feed-name}/nuget/v3/index.json

Release feed resolution

The scripts use this precedence on release/* branches:

1. ASPIRE_RELEASE_FEED_URL — accepts the full NuGet service index URL, the Azure DevOps feed page URL, or the raw feed name
2. ASPIRE_RELEASE_FEED_NAME — explicit feed name such as darc-pub-microsoft-aspire-aad16017
3. ASPIRE_RELEASE_COMMIT / ASPIRE_RELEASE_COMMIT_SHA — derives the feed name from the commit SHA prefix
4. Automatic lookup of the matching branch head via git ls-remote against https://github.com/microsoft/aspire

If the Aspire release branch is not publicly reachable yet, set one of the override environment variables above. The scripts intentionally fail on release/* if the official release feed cannot be resolved, to avoid accidentally ingesting stale nuget.org packages.

When the commit-specific feed is unavailable but a shared feed contains the required build, set ASPIRE_RELEASE_FEED_URL and ASPIRE_RELEASE_VERSION together. The version must be an exact package version matching the release branch, not a range. Official packages select only that version; Toolkit packages keep their normal nuget.org selection. Packages absent from that build retain an existing catalog entry, if any, rather than importing a different release. An unavailable pin for the entire integration set, an unlisted/deprecated pinned version, or a pinned registration lookup failure stops the update before the catalog is written. Selected-version registration metadata supplies release descriptions and tags. Where no published nuget.org icon metadata exists, the updater reports use of the public Aspire site icon instead of embedding an unpublished or authenticated-feed image URL.

For an app-managed worktree whose branch name is not release/*, set BUILD_SOURCEBRANCH=refs/heads/release/N.N in the update process alongside those overrides. This supplies the existing branch-resolution context without renaming or switching the worktree. Do not set these variables globally. Review the resolved source and version before regeneration; C# and TypeScript generators consume the resulting catalog's exact versions.

Step-by-Step Process

1. Run the update script

Fetch the latest package data from the configured package feeds:

pnpm --dir ./src/frontend update:integrations

This writes updated package metadata to src/frontend/src/data/aspire-integrations.json. The script queries the NuGet v3 API for packages matching owner:aspire, Aspire.Hosting., and CommunityToolkit.Aspire, then filters out deprecated, unlisted, and excluded packages.

It also removes documentation mappings for Aspire and Community Toolkit packages absent from the updated catalog. Manually curated third-party mappings are preserved, and new documentation URLs still require manual resolution.

On release/* branches, the script queries the branch-specific official Aspire feed for Aspire.* packages and continues to query nuget.org for CommunityToolkit.Aspire.* packages.

2. Read the updated package data

Load src/frontend/src/data/aspire-integrations.json and extract all package names from the title field of each entry in the JSON array.

3. Update integration documentation mappings

Load src/frontend/src/data/integration-docs.json and reconcile it with the package list:

• For each package name (from title field) in aspire-integrations.json:

  • Check if a matching entry exists in integration-docs.json (where match equals the package name)
  • If an entry exists, verify the href is correct
  • If no entry exists, determine the appropriate documentation URL

• Remove stale entries for catalog-managed Aspire and Community Toolkit packages no longer in aspire-integrations.json. Preserve mappings for third-party packages outside the catalog's sources.

• Preserve existing correct mappings — do not change entries that are already accurate

4. Determining documentation URLs

When a package has no existing mapping, determine the URL based on:

Package name patterns

Technology categories

The documentation site organizes integrations into these categories:

URL resolution strategy

1. Match against existing similar package mappings in integration-docs.json
2. Infer from the package name and technology category
3. Verify the page exists — check the file system under src/frontend/src/content/docs/, then use Playwright CLI to confirm the route renders
4. If no valid documentation page can be found, flag the package for manual review

5. Generate API reference data

After updating the integration catalog, regenerate the per-package API reference JSON files. The generate-package-json.ps1 script automates this:

cd src/tools/PackageJsonGenerator && pwsh ./generate-package-json.ps1

The script performs the following for every package listed in aspire-integrations.json:

1. Resolves the correct package source per package: official Aspire packages use the branch-specific release feed on release/*, while Community Toolkit packages continue to use nuget.org.
2. Queries that package source for the latest stable version (falls back to latest preview if no stable exists).
3. Downloads the package into the local NuGet cache via dotnet restore if not already cached. Provisioning SDK overlays restore with the same-version Aspire.Hosting reference to model their AppHost context; other packages retain standalone per-package restore graphs. Dependency errors remain fatal. Restores run in parallel, up to 8 at a time by default (-Parallelism changes the limit; -Sequential restores one package at a time). A failed dotnet restore is attempted up to three times before the package counts as failed.
4. Selects the best-matching target framework folder (prefers net10.0, then net9.0, etc.).
5. Uses Roslyn to analyze the assembly and extract all public types, members, XML docs, and attributes.
6. Writes a {Package}.{Version}.json file to src/frontend/src/data/pkgs/.

An assembly that opts into an AspireExportProvider can expose generated ATS APIs without public C# types. For those assemblies, the generator retains package identity and provenance with types: [] and package.hasGeneratedExports: true. This record feeds TypeScript generation and requires a corresponding TypeScript module at semantic validation. It does not add an empty C# package to API navigation. Build-only packages without public types or generated-export opt-ins remain explicit skips.

The generated JSON follows this schema:

{
  "package": {
    "name": "Aspire.Hosting.Redis",
    "version": "13.1.2",
    "targetFramework": "net10.0"
  },
  "types": [
    {
      "name": "TypeName",
      "fullName": "Namespace.TypeName",
      "namespace": "Namespace",
      "kind": "class",
      "accessibility": "public",
      "members": [ ... ],
      "docs": { ... }
    }
  ]
}

These files are consumed by the packages content collection defined in src/frontend/src/content.config.ts and used to render API reference pages at /reference/api/{package}/{type}/.

Selective regeneration

To regenerate API data for specific packages only:

pwsh ./generate-package-json.ps1 -Packages @("Aspire.Hosting.Redis", "Aspire.Hosting.PostgreSQL")

Targeting a different framework

To use a different target framework (e.g. net10.0):

pwsh ./generate-package-json.ps1 -Framework "net10.0"