@spinnaker/core 2026.2.2 → 2026.3.0

package/src/loadBalancer/filter/LoadBalancerFilterService.ts

@@ -1,6 +1,5 @@
 import { chain, find, forOwn, groupBy, includes, intersection, map, some, sortBy, values, without } from 'lodash';
 import { Debounce } from 'lodash-decorators';
-import { $log } from 'ngimport';
 import { Subject } from 'rxjs';
 
 import type { Application } from '../../application/application.model';
@@ -8,6 +7,7 @@ import type { IInstance, ILoadBalancer, ILoadBalancerGroup, IServerGroup } from
 import type { ISortFilter } from '../../filterModel';
 import { FilterModelService } from '../../filterModel';
 import { LoadBalancerState } from '../../state';
+import { diagnosticLogger } from '../../utils/diagnosticLogger';
 
 export class LoadBalancerFilterService {
   public groupsUpdatedStream: Subject<ILoadBalancerGroup[]> = new Subject<ILoadBalancerGroup[]>();
@@ -150,7 +150,7 @@ export class LoadBalancerFilterService {
         region: serverGroup.region,
       });
       if (!newServerGroup) {
-        $log.debug(
+        diagnosticLogger.debug(
           'server group no longer found, removing:',
           serverGroup.name,
           serverGroup.account,
@@ -160,7 +160,7 @@ export class LoadBalancerFilterService {
       } else {
         newServerGroup.stringVal = newServerGroup.stringVal || JSON.stringify(newServerGroup, this.jsonReplacer);
         if (serverGroup.stringVal !== newServerGroup.stringVal) {
-          $log.debug(
+          diagnosticLogger.debug(
             'change detected, updating server group:',
             serverGroup.name,
             serverGroup.account,
@@ -180,7 +180,12 @@ export class LoadBalancerFilterService {
         region: serverGroup.region,
       });
       if (!oldServerGroup) {
-        $log.debug('new server group found, adding', serverGroup.name, serverGroup.account, serverGroup.region);
+        diagnosticLogger.debug(
+          'new server group found, adding',
+          serverGroup.name,
+          serverGroup.account,
+          serverGroup.region,
+        );
         oldGroup.serverGroups.push(serverGroup);
       }
     });
@@ -189,7 +194,7 @@ export class LoadBalancerFilterService {
   public sortGroupsByHeading(groups: ILoadBalancerGroup[]): void {
     this.diffSubgroups(LoadBalancerState.filterModel.asFilterModel.groups, groups);
 
-    // sort groups in place so Angular doesn't try to update the world
+    // Preserve the groups array identity for existing subscribers.
     LoadBalancerState.filterModel.asFilterModel.groups.sort((a, b) => {
       if (a.heading < b.heading) {
         return -1;

package/src/loadBalancer/filter/LoadBalancerFilters.tsx

@@ -1,5 +1,4 @@
 import { chain, cloneDeep, compact, debounce, map, uniq } from 'lodash';
-import { $rootScope } from 'ngimport';
 import React from 'react';
 import type { Subscription } from 'rxjs';
 
@@ -8,6 +7,8 @@ import { FilterSearch } from '../../cluster/filter/FilterSearch';
 import { FilterSection } from '../../cluster/filter/FilterSection';
 import type { ISortFilter } from '../../filterModel';
 import { digestDependentFilters, FilterCheckbox } from '../../filterModel';
+import type { IRouterInjectedProps } from '../../navigation/routerContext';
+import { locationChangeSuccess$, withRouter } from '../../navigation/routerContext';
 import { LoadBalancerState } from '../../state';
 
 const poolValueCoordinates = [
@@ -75,13 +76,16 @@ export interface ILoadBalancerFiltersState {
   detailHeadings: string[];
 }
 
-export class LoadBalancerFilters extends React.Component<ILoadBalancerFiltersProps, ILoadBalancerFiltersState> {
+class LoadBalancerFiltersComponent extends React.Component<
+  ILoadBalancerFiltersProps & IRouterInjectedProps,
+  ILoadBalancerFiltersState
+> {
   private debouncedUpdateLoadBalancerGroups: () => void;
   private groupsUpdatedSubscription: Subscription;
   private loadBalancersRefreshUnsubscribe: () => void;
   private locationChangeUnsubscribe: () => void;
 
-  constructor(props: ILoadBalancerFiltersProps) {
+  constructor(props: ILoadBalancerFiltersProps & IRouterInjectedProps) {
     super(props);
     this.state = {
       sortFilter: LoadBalancerState.filterModel.asFilterModel.sortFilter,
@@ -109,12 +113,13 @@ export class LoadBalancerFilters extends React.Component<ILoadBalancerFiltersPro
       this.updateLoadBalancerGroups();
     }
 
-    this.loadBalancersRefreshUnsubscribe = app.loadBalancers.onRefresh(null, () => this.updateLoadBalancerGroups());
+    this.loadBalancersRefreshUnsubscribe = app.loadBalancers.onRefresh(() => this.updateLoadBalancerGroups());
 
-    this.locationChangeUnsubscribe = $rootScope.$on('$locationChangeSuccess', () => {
+    const locationChangeSubscription = locationChangeSuccess$(this.props.router).subscribe(() => {
       LoadBalancerState.filterModel.asFilterModel.activate();
       LoadBalancerState.filterService.updateLoadBalancerGroups(app);
     });
+    this.locationChangeUnsubscribe = () => locationChangeSubscription.unsubscribe();
   }
 
   public componentWillUnmount(): void {
@@ -321,3 +326,6 @@ export class LoadBalancerFilters extends React.Component<ILoadBalancerFiltersPro
     );
   }
 }
+
+export const LoadBalancerFilters = withRouter(LoadBalancerFiltersComponent);
+LoadBalancerFilters.displayName = 'LoadBalancerFilters';

package/src/loadBalancer/loadBalancer.dataSource.spec.ts

@@ -0,0 +1,33 @@
+import { ApplicationDataSourceRegistry } from '../application/service/ApplicationDataSourceRegistry';
+import type { DeckRuntime } from '../bootstrap/DeckRuntime';
+import { createDeckRuntime } from '../bootstrap/DeckRuntime';
+import { registerLoadBalancerDataSource } from './loadBalancer.dataSource';
+
+describe('direct runtime load balancer data source registration', () => {
+  let runtime: DeckRuntime;
+
+  beforeEach(() => {
+    runtime = createDeckRuntime();
+    ApplicationDataSourceRegistry.clearDataSources();
+  });
+
+  afterEach(() => {
+    runtime.dispose();
+    ApplicationDataSourceRegistry.clearDataSources();
+  });
+
+  it('loads through the shared reader and returns a Promise-compatible onLoad result', async () => {
+    const loadBalancers = [{ name: 'app-test-detail' }] as any[];
+    const loadBalancerReader = {
+      loadLoadBalancers: jasmine.createSpy('loadLoadBalancers').and.returnValue(Promise.resolve(loadBalancers)),
+    };
+    registerLoadBalancerDataSource(runtime.promiseService, loadBalancerReader as any);
+    const dataSource = ApplicationDataSourceRegistry.getDataSources()[0];
+
+    await expectAsync(Promise.resolve(dataSource.loader({ name: 'app' } as any))).toBeResolvedTo(loadBalancers);
+    await expectAsync(Promise.resolve(dataSource.onLoad({ name: 'app' } as any, loadBalancers))).toBeResolvedTo(
+      loadBalancers,
+    );
+    expect(loadBalancerReader.loadLoadBalancers).toHaveBeenCalledWith('app');
+  });
+});

package/src/loadBalancer/loadBalancer.dataSource.ts

@@ -1,48 +1,56 @@
-import type { IQService } from 'angular';
-import { module } from 'angular';
-
 import type { Application } from '../application/application.model';
 import { INFRASTRUCTURE_KEY } from '../application/nav/defaultCategories';
 import { ApplicationDataSourceRegistry } from '../application/service/ApplicationDataSourceRegistry';
 import type { ILoadBalancer } from '../domain';
 import { EntityTagsReader } from '../entityTag/EntityTagsReader';
 import type { LoadBalancerReader } from './loadBalancer.read.service';
-import { LOAD_BALANCER_READ_SERVICE } from './loadBalancer.read.service';
 import { addManagedResourceMetadataToLoadBalancers } from '../managed';
+import type { PromiseService } from '../utils/nativePromiseService';
+
+function createDataSourceConfig(
+  resolve: <T>(value: T | PromiseLike<T>) => Promise<Awaited<T>>,
+  loadBalancerReader: LoadBalancerReader,
+) {
+  const loadLoadBalancers = (application: Application) => {
+    return loadBalancerReader.loadLoadBalancers(application.name);
+  };
+
+  const addLoadBalancers = (_application: Application, loadBalancers: ILoadBalancer[]) => {
+    return resolve(loadBalancers);
+  };
 
-export const LOAD_BALANCER_DATA_SOURCE = 'spinnaker.core.loadBalancer.dataSource';
-module(LOAD_BALANCER_DATA_SOURCE, [LOAD_BALANCER_READ_SERVICE]).run([
-  '$q',
-  'loadBalancerReader',
-  ($q: IQService, loadBalancerReader: LoadBalancerReader) => {
-    const loadLoadBalancers = (application: Application) => {
-      return loadBalancerReader.loadLoadBalancers(application.name);
-    };
+  const addTags = (application: Application) => {
+    EntityTagsReader.addTagsToLoadBalancers(application);
+    addManagedResourceMetadataToLoadBalancers(application);
+  };
 
-    const addLoadBalancers = (_application: Application, loadBalancers: ILoadBalancer[]) => {
-      return $q.when(loadBalancers);
-    };
+  return {
+    key: 'loadBalancers',
+    sref: '.insight.loadBalancers',
+    category: INFRASTRUCTURE_KEY,
+    optional: true,
+    icon: 'fa fa-xs fa-fw icon-sitemap',
+    iconName: 'spMenuLoadBalancers' as const,
+    loader: loadLoadBalancers,
+    onLoad: addLoadBalancers,
+    afterLoad: addTags,
+    providerField: 'cloudProvider',
+    credentialsField: 'account',
+    regionField: 'region',
+    description: 'Traffic distribution management between servers',
+    defaultData: [] as ILoadBalancer[],
+  };
+}
 
-    const addTags = (application: Application) => {
-      EntityTagsReader.addTagsToLoadBalancers(application);
-      addManagedResourceMetadataToLoadBalancers(application);
-    };
+export function registerLoadBalancerDataSource(
+  promiseService: PromiseService,
+  loadBalancerReader: LoadBalancerReader,
+): void {
+  if (ApplicationDataSourceRegistry.getDataSources().some((source) => source.key === 'loadBalancers')) {
+    return;
+  }
 
-    ApplicationDataSourceRegistry.registerDataSource({
-      key: 'loadBalancers',
-      sref: '.insight.loadBalancers',
-      category: INFRASTRUCTURE_KEY,
-      optional: true,
-      icon: 'fa fa-xs fa-fw icon-sitemap',
-      iconName: 'spMenuLoadBalancers',
-      loader: loadLoadBalancers,
-      onLoad: addLoadBalancers,
-      afterLoad: addTags,
-      providerField: 'cloudProvider',
-      credentialsField: 'account',
-      regionField: 'region',
-      description: 'Traffic distribution management between servers',
-      defaultData: [],
-    });
-  },
-]);
+  ApplicationDataSourceRegistry.registerDataSource(
+    createDataSourceConfig(<T>(value: T | PromiseLike<T>) => promiseService.resolve(value), loadBalancerReader),
+  );
+}

package/src/loadBalancer/loadBalancer.module.ts

@@ -1,9 +1,2 @@
-import { module } from 'angular';
-
-import { LOAD_BALANCER_DATA_SOURCE } from './loadBalancer.dataSource';
-import { LOAD_BALANCER_STATES } from './loadBalancer.states';
+import './loadBalancer.states';
 import './loadBalancerSearchResultType';
-
-export const LOAD_BALANCER_MODULE = 'spinnaker.core.loadBalancer';
-
-module(LOAD_BALANCER_MODULE, [LOAD_BALANCER_DATA_SOURCE, LOAD_BALANCER_STATES]);

package/src/loadBalancer/loadBalancer.read.service.spec.ts

@@ -0,0 +1,56 @@
+import { mockHttpClient } from '../api/mock/jasmine';
+import type { DeckRuntime } from '../bootstrap/DeckRuntime';
+import { createDeckRuntime } from '../bootstrap/DeckRuntime';
+import { CloudProviderRegistry } from '../cloudProvider';
+import { SETTINGS } from '../config';
+
+describe('direct runtime load balancer reader', () => {
+  const provider = 'directRuntimeLoadBalancerReaderTest';
+  let runtime: DeckRuntime;
+
+  beforeEach(() => {
+    SETTINGS.providers[provider] = { enabled: true };
+    runtime = createDeckRuntime();
+  });
+
+  afterEach(() => {
+    runtime.dispose();
+    delete SETTINGS.providers[provider];
+    (CloudProviderRegistry as any).providers.delete(provider);
+  });
+
+  it('normalizes load balancers with the registered provider transformer', async () => {
+    class TestLoadBalancerTransformer {
+      public normalizeLoadBalancer(loadBalancer: any) {
+        return Promise.resolve({ ...loadBalancer, transformed: true });
+      }
+    }
+
+    CloudProviderRegistry.registerProvider(provider, {
+      name: 'Direct Runtime Load Balancer Reader Test',
+      loadBalancer: { transformer: TestLoadBalancerTransformer },
+    });
+    const http = mockHttpClient();
+    http.expectGET('/applications/app/loadBalancers').respond(200, [
+      {
+        name: 'app-test-detail',
+        provider,
+      },
+    ]);
+
+    const loadBalancersPromise = runtime.services.loadBalancerReader.loadLoadBalancers('app');
+    await http.flush();
+    const loadBalancers = await loadBalancersPromise;
+
+    expect(loadBalancers).toEqual([
+      jasmine.objectContaining({
+        name: 'app-test-detail',
+        provider,
+        cloudProvider: provider,
+        stack: 'test',
+        detail: 'detail',
+        transformed: true,
+      }),
+    ]);
+  });
+});

package/src/loadBalancer/loadBalancer.read.service.ts

@@ -1,11 +1,8 @@
-import type { IQService } from 'angular';
-import { module } from 'angular';
-
 import { REST } from '../api/ApiService';
 import type { ILoadBalancer, ILoadBalancerSourceData } from '../domain';
-import { CORE_LOADBALANCER_LOADBALANCER_TRANSFORMER } from './loadBalancer.transformer';
 import type { IComponentName } from '../naming';
 import { NameUtils } from '../naming';
+import type { PromiseService } from '../utils/nativePromiseService';
 
 export interface ILoadBalancersByAccount {
   name: string;
@@ -19,16 +16,15 @@ export interface ILoadBalancersByAccount {
 }
 
 export class LoadBalancerReader {
-  public static $inject = ['$q', 'loadBalancerTransformer'];
-  public constructor(private $q: IQService, private loadBalancerTransformer: any) {}
+  public constructor(private promiseService: PromiseService, private loadBalancerTransformer: any) {}
 
-  public loadLoadBalancers(applicationName: string): PromiseLike<ILoadBalancerSourceData[]> {
+  public loadLoadBalancers(applicationName: string): Promise<ILoadBalancerSourceData[]> {
     return REST('/applications')
       .path(applicationName, 'loadBalancers')
       .get()
       .then((loadBalancers: ILoadBalancerSourceData[]) => {
         loadBalancers = this.loadBalancerTransformer.normalizeLoadBalancerSet(loadBalancers);
-        return this.$q.all(loadBalancers.map((lb) => this.normalizeLoadBalancer(lb)));
+        return this.promiseService.all(loadBalancers.map((lb) => this.normalizeLoadBalancer(lb)));
       });
   }
 
@@ -37,15 +33,15 @@ export class LoadBalancerReader {
     account: string,
     region: string,
     name: string,
-  ): PromiseLike<ILoadBalancerSourceData[]> {
+  ): Promise<ILoadBalancerSourceData[]> {
     return REST('/loadBalancers').path(account, region, name).query({ provider: cloudProvider }).get();
   }
 
-  public listLoadBalancers(cloudProvider: string): PromiseLike<ILoadBalancersByAccount[]> {
+  public listLoadBalancers(cloudProvider: string): Promise<ILoadBalancersByAccount[]> {
     return REST('/loadBalancers').query({ provider: cloudProvider }).get();
   }
 
-  private normalizeLoadBalancer(loadBalancer: ILoadBalancerSourceData): PromiseLike<ILoadBalancer> {
+  private normalizeLoadBalancer(loadBalancer: ILoadBalancerSourceData): Promise<ILoadBalancer> {
     return this.loadBalancerTransformer.normalizeLoadBalancer(loadBalancer).then((lb: ILoadBalancer) => {
       const nameParts: IComponentName = NameUtils.parseLoadBalancerName(lb.name);
       lb.stack = nameParts.stack;
@@ -55,10 +51,3 @@ export class LoadBalancerReader {
     });
   }
 }
-
-export const LOAD_BALANCER_READ_SERVICE = 'spinnaker.core.loadBalancer.read.service';
-
-module(LOAD_BALANCER_READ_SERVICE, [CORE_LOADBALANCER_LOADBALANCER_TRANSFORMER]).service(
-  'loadBalancerReader',
-  LoadBalancerReader,
-);

package/src/loadBalancer/loadBalancer.states.ts

@@ -1,10 +1,10 @@
-import type { StateParams } from '@uirouter/angularjs';
-import { module } from 'angular';
+import type { RawParams } from '@uirouter/core';
 
 import { LoadBalancers } from './LoadBalancers';
 import type { ApplicationStateProvider } from '../application';
-import { APPLICATION_STATE_PROVIDER } from '../application';
+import { registerApplicationState } from '../application';
 import { LoadBalancerDetails } from './details';
+import { TargetGroupDetails } from './details/TargetGroupDetailsWrapper';
 import { filterModelConfig } from './filter/LoadBalancerFilterModel';
 import { LoadBalancerFilters } from './filter/LoadBalancerFilters';
 import type { INestedState, StateConfigProvider } from '../navigation';
@@ -17,10 +17,7 @@ export interface ILoadBalancerStateParams {
   provider: string;
 }
 
-export const LOAD_BALANCER_STATES = 'spinnaker.core.loadBalancer.states';
-module(LOAD_BALANCER_STATES, [APPLICATION_STATE_PROVIDER]).config([
-  'applicationStateProvider',
-  'stateConfigProvider',
+registerApplicationState(
   (applicationStateProvider: ApplicationStateProvider, stateConfigProvider: StateConfigProvider) => {
     const loadBalancerDetails: INestedState = {
       name: 'loadBalancerDetails',
@@ -38,10 +35,10 @@ module(LOAD_BALANCER_STATES, [APPLICATION_STATE_PROVIDER]).config([
         },
       },
       resolve: {
-        accountId: ['$stateParams', ($stateParams: StateParams) => $stateParams.accountId],
+        accountId: ['$stateParams', ($stateParams: RawParams) => $stateParams.accountId],
         loadBalancer: [
           '$stateParams',
-          ($stateParams: StateParams): ILoadBalancerStateParams => {
+          ($stateParams: RawParams): ILoadBalancerStateParams => {
             return {
               name: $stateParams.name,
               accountId: $stateParams.accountId,
@@ -65,6 +62,47 @@ module(LOAD_BALANCER_STATES, [APPLICATION_STATE_PROVIDER]).config([
       },
     };
 
+    const targetGroupDetails: INestedState = {
+      name: 'targetGroupDetails',
+      url: '/targetGroupDetails/:provider/:accountId/:region/:vpcId/:loadBalancerName/:name',
+      params: {
+        vpcId: {
+          value: null,
+          squash: true,
+        },
+      },
+      views: {
+        'detail@../insight': {
+          component: TargetGroupDetails,
+          $type: 'react',
+        },
+      },
+      resolve: {
+        accountId: ['$stateParams', ($stateParams: RawParams) => $stateParams.accountId],
+        name: ['$stateParams', ($stateParams: RawParams) => $stateParams.name],
+        provider: ['$stateParams', ($stateParams: RawParams) => $stateParams.provider],
+        targetGroup: [
+          '$stateParams',
+          ($stateParams: RawParams) => ({
+            accountId: $stateParams.accountId,
+            loadBalancerName: $stateParams.loadBalancerName,
+            name: $stateParams.name,
+            provider: $stateParams.provider,
+            region: $stateParams.region,
+            vpcId: $stateParams.vpcId,
+          }),
+        ],
+      },
+      data: {
+        pageTitleDetails: {
+          title: 'Target Group Details',
+          nameParam: 'name',
+          accountParam: 'accountId',
+          regionParam: 'region',
+        },
+      },
+    };
+
     const loadBalancers: INestedState = {
       url: `/loadBalancers?${stateConfigProvider.paramsToQuery(filterModelConfig)}`,
       name: 'loadBalancers',
@@ -83,5 +121,6 @@ module(LOAD_BALANCER_STATES, [APPLICATION_STATE_PROVIDER]).config([
 
     applicationStateProvider.addInsightState(loadBalancers);
     applicationStateProvider.addInsightDetailState(loadBalancerDetails);
+    applicationStateProvider.addInsightDetailState(targetGroupDetails);
   },
-]);
+);

package/src/loadBalancer/loadBalancer.transformer.js

@@ -1,43 +1,35 @@
 'use strict';
 
-import { module } from 'angular';
-import { chain, flow } from 'lodash';
+import { chain } from 'lodash';
 
-import { PROVIDER_SERVICE_DELEGATE } from '../cloudProvider/providerService.delegate';
-
-export const CORE_LOADBALANCER_LOADBALANCER_TRANSFORMER = 'spinnaker.core.loadBalancer.transformer';
-export const name = CORE_LOADBALANCER_LOADBALANCER_TRANSFORMER; // for backwards compatibility
-module(CORE_LOADBALANCER_LOADBALANCER_TRANSFORMER, [PROVIDER_SERVICE_DELEGATE]).factory('loadBalancerTransformer', [
-  'providerServiceDelegate',
-  function (providerServiceDelegate) {
-    function normalizeLoadBalancer(loadBalancer) {
-      return providerServiceDelegate
-        .getDelegate(loadBalancer.provider || loadBalancer.type, 'loadBalancer.transformer')
-        .normalizeLoadBalancer(loadBalancer);
+export function createLoadBalancerTransformer(providerServiceDelegate) {
+  function normalizeLoadBalancer(loadBalancer) {
+    const provider = loadBalancer.provider || loadBalancer.type;
+    if (!providerServiceDelegate.hasDelegate(provider, 'loadBalancer.transformer')) {
+      return Promise.resolve(loadBalancer);
     }
 
-    function normalizeLoadBalancerSet(loadBalancers) {
-      const setNormalizers = chain(loadBalancers)
-        .filter((lb) => providerServiceDelegate.hasDelegate(lb.provider || lb.type, 'loadBalancer.setTransformer'))
-        .compact()
-        .map(
-          (lb) =>
-            providerServiceDelegate.getDelegate(lb.provider || lb.type, 'loadBalancer.setTransformer')
-              .normalizeLoadBalancerSet,
-        )
-        .uniq()
-        .value();
+    return providerServiceDelegate
+      .getDelegate(provider, 'loadBalancer.transformer')
+      .normalizeLoadBalancer(loadBalancer);
+  }
 
-      if (setNormalizers.length) {
-        return flow(setNormalizers)(loadBalancers);
-      } else {
-        return loadBalancers;
-      }
-    }
+  function normalizeLoadBalancerSet(loadBalancers) {
+    const setTransformers = chain(loadBalancers)
+      .map((loadBalancer) => loadBalancer.provider || loadBalancer.type)
+      .uniq()
+      .filter((provider) => providerServiceDelegate.hasDelegate(provider, 'loadBalancer.setTransformer'))
+      .map((provider) => providerServiceDelegate.getDelegate(provider, 'loadBalancer.setTransformer'))
+      .value();
+
+    return setTransformers.reduce(
+      (currentLoadBalancers, transformer) => transformer.normalizeLoadBalancerSet(currentLoadBalancers),
+      loadBalancers,
+    );
+  }
 
-    return {
-      normalizeLoadBalancer: normalizeLoadBalancer,
-      normalizeLoadBalancerSet: normalizeLoadBalancerSet,
-    };
-  },
-]);
+  return {
+    normalizeLoadBalancer: normalizeLoadBalancer,
+    normalizeLoadBalancerSet: normalizeLoadBalancerSet,
+  };
+}

package/src/loadBalancer/loadBalancer.transformer.spec.ts

@@ -0,0 +1,91 @@
+import { createLoadBalancerTransformer } from './loadBalancer.transformer';
+
+describe('createLoadBalancerTransformer', () => {
+  const provider = 'loadBalancerTransformerTest';
+
+  it('preserves provider item and set normalization', async () => {
+    const normalizeLoadBalancerSet = jasmine
+      .createSpy('normalizeLoadBalancerSet')
+      .and.callFake((loadBalancers: any[]) => loadBalancers.slice().reverse());
+    const providerTransformer = {
+      context: provider,
+      normalizeLoadBalancer(loadBalancer: any) {
+        return Promise.resolve({ ...loadBalancer, context: this.context });
+      },
+    };
+    const providerSetTransformer = { normalizeLoadBalancerSet };
+    const providerServiceDelegate = {
+      hasDelegate: jasmine.createSpy('hasDelegate').and.callFake((requestedProvider: string, serviceKey: string) => {
+        return (
+          requestedProvider === provider &&
+          ['loadBalancer.transformer', 'loadBalancer.setTransformer'].includes(serviceKey)
+        );
+      }),
+      getDelegate: jasmine.createSpy('getDelegate').and.callFake((_requestedProvider: string, serviceKey: string) => {
+        return serviceKey === 'loadBalancer.transformer' ? providerTransformer : providerSetTransformer;
+      }),
+    };
+    const transformer = createLoadBalancerTransformer(providerServiceDelegate);
+    const loadBalancers = [
+      { name: 'app-test-detail', provider },
+      { name: 'app-test-other', provider },
+    ];
+
+    await expectAsync(transformer.normalizeLoadBalancer(loadBalancers[0])).toBeResolvedTo(
+      jasmine.objectContaining({ context: provider }),
+    );
+    expect(transformer.normalizeLoadBalancerSet(loadBalancers)).toEqual(loadBalancers.slice().reverse());
+    expect(normalizeLoadBalancerSet).toHaveBeenCalledTimes(1);
+    expect(providerServiceDelegate.getDelegate).toHaveBeenCalledWith(provider, 'loadBalancer.transformer');
+    expect(providerServiceDelegate.getDelegate).toHaveBeenCalledWith(provider, 'loadBalancer.setTransformer');
+  });
+
+  it('resolves each provider set transformer once', () => {
+    const secondProvider = `${provider}Second`;
+    const resolvedProviders: string[] = [];
+    const createdDelegates: any[] = [];
+    const invokedDelegates: any[] = [];
+    const providerServiceDelegate = {
+      hasDelegate: jasmine.createSpy('hasDelegate').and.returnValue(true),
+      getDelegate: jasmine.createSpy('getDelegate').and.callFake((requestedProvider: string) => {
+        resolvedProviders.push(requestedProvider);
+        const delegate = {
+          normalizeLoadBalancerSet(loadBalancers: any[]) {
+            invokedDelegates.push(this);
+            return loadBalancers;
+          },
+        };
+        createdDelegates.push(delegate);
+        return delegate;
+      }),
+    };
+    const transformer = createLoadBalancerTransformer(providerServiceDelegate);
+    const loadBalancers = [
+      { name: 'app-test-one', provider },
+      { name: 'app-test-two', provider },
+      { name: 'app-test-three', provider: secondProvider },
+      { name: 'app-test-four', provider },
+      { name: 'app-test-five', provider: secondProvider },
+    ];
+
+    expect(transformer.normalizeLoadBalancerSet(loadBalancers)).toBe(loadBalancers);
+    expect(resolvedProviders).toEqual([provider, secondProvider]);
+    expect(providerServiceDelegate.hasDelegate.calls.allArgs()).toEqual([
+      [provider, 'loadBalancer.setTransformer'],
+      [secondProvider, 'loadBalancer.setTransformer'],
+    ]);
+    expect(invokedDelegates).toEqual(createdDelegates);
+  });
+
+  it('leaves unregistered providers unchanged', async () => {
+    const providerServiceDelegate = {
+      hasDelegate: jasmine.createSpy('hasDelegate').and.returnValue(false),
+      getDelegate: jasmine.createSpy('getDelegate'),
+    };
+    const transformer = createLoadBalancerTransformer(providerServiceDelegate);
+    const loadBalancer = { name: 'app-test-detail', provider };
+
+    await expectAsync(transformer.normalizeLoadBalancer(loadBalancer)).toBeResolvedTo(loadBalancer);
+    expect(providerServiceDelegate.getDelegate).not.toHaveBeenCalled();
+  });
+});

package/src/loadBalancer/loadBalancer.write.service.ts

@@ -27,7 +27,7 @@ export interface ILoadBalancerDeleteCommand extends IJob {
 }
 
 export class LoadBalancerWriter {
-  public static deleteLoadBalancer(command: ILoadBalancerDeleteCommand, application: Application): PromiseLike<ITask> {
+  public static deleteLoadBalancer(command: ILoadBalancerDeleteCommand, application: Application): Promise<ITask> {
     command.type = 'deleteLoadBalancer';
 
     return TaskExecutor.executeTask({
@@ -42,7 +42,7 @@ export class LoadBalancerWriter {
     application: Application,
     descriptor: string,
     params: any = {},
-  ): PromiseLike<ITask> {
+  ): Promise<ITask> {
     Object.assign(command, params);
     command.type = 'upsertLoadBalancer';
 

package/src/loadBalancer/loadBalancerDataUtils.ts

@@ -27,10 +27,7 @@ export class LoadBalancerDataUtils {
     return loadBalancer;
   }
 
-  public static populateLoadBalancers(
-    application: Application,
-    serverGroup: IServerGroup,
-  ): PromiseLike<ILoadBalancer[]> {
+  public static populateLoadBalancers(application: Application, serverGroup: IServerGroup): Promise<ILoadBalancer[]> {
     return application
       .getDataSource('loadBalancers')
       .ready()