@spinnaker/core 2026.2.2 → 2026.3.0

package/src/search/infrastructure/SearchV1.tsx

@@ -0,0 +1,289 @@
+import React from 'react';
+import { from as observableFrom, of as observableOf, Subject } from 'rxjs';
+import { catchError, debounceTime, distinctUntilChanged, map, switchMap, takeUntil } from 'rxjs/operators';
+
+import { ProjectSummaryPod } from './ProjectSummaryPod';
+import { RecentlyViewedItems } from './RecentlyViewedItems';
+import { SearchResult } from './SearchResult';
+import { SearchResultPods } from './SearchResultPods';
+import type { IDeckRuntimeServicesInjectedProps } from '../../bootstrap/DeckRuntimeContext';
+import { withDeckRuntimeServices } from '../../bootstrap/DeckRuntimeContext';
+import type { ISearchResultSet } from './infrastructureSearch.service';
+import { InsightMenu } from '../../insight/InsightMenu';
+import type { IRouterInjectedProps } from '../../navigation/routerContext';
+import { withRouter } from '../../navigation/routerContext';
+import type { ISearchResult } from '../search.service';
+import { SearchService } from '../search.service';
+import { searchRank } from '../searchRank.filter';
+import { FirewallLabels } from '../../securityGroup/label';
+import { ClusterState } from '../../state';
+import { Spinner } from '../../widgets';
+
+const MIN_SEARCH_LENGTH = 3;
+const QUERY_DEBOUNCE_MS = 300;
+
+export interface ISearchV1State {
+  categories: ISearchResultSet[];
+  moreResults: boolean;
+  projects: ISearchResultSet[];
+  query: string;
+  searching: boolean;
+  showMinLengthWarning: boolean;
+}
+
+export class SearchV1Component extends React.Component<
+  IRouterInjectedProps & IDeckRuntimeServicesInjectedProps,
+  ISearchV1State
+> {
+  private search = this.props.deckRuntimeServices.infrastructureSearchService.getSearcher();
+  private autoNavigateQuery: string | null = this.props.stateParams.route ? this.props.stateParams.q || '' : null;
+  private destroy$ = new Subject<void>();
+  private query$ = new Subject<string>();
+
+  public state: ISearchV1State = {
+    categories: [],
+    moreResults: false,
+    projects: [],
+    query: this.props.stateParams.q || '',
+    searching: false,
+    showMinLengthWarning: false,
+  };
+
+  public componentDidMount(): void {
+    this.query$
+      .pipe(
+        debounceTime(QUERY_DEBOUNCE_MS),
+        switchMap((query) =>
+          observableFrom(this.search.query(query)).pipe(
+            map((resultSets) => ({ query, resultSets })),
+            catchError(() => observableOf({ query, resultSets: [] as ISearchResultSet[] })),
+          ),
+        ),
+        takeUntil(this.destroy$),
+      )
+      .subscribe(({ query, resultSets }) => this.handleResults(query, resultSets));
+
+    this.props.router.globals.params$
+      .pipe(
+        map((params) => params.q || ''),
+        distinctUntilChanged(),
+        takeUntil(this.destroy$),
+      )
+      .subscribe((query) => {
+        if (query !== this.state.query) {
+          this.handleQueryChange(query);
+        }
+      });
+
+    if (this.autoNavigateQuery !== null) {
+      this.props.stateService.go('.', { route: null }, { location: 'replace' });
+    }
+
+    this.updatePageTitle(this.state.query);
+    this.queueQuery(this.state.query);
+  }
+
+  public componentWillUnmount(): void {
+    this.destroy$.next();
+    this.destroy$.complete();
+  }
+
+  public handleQueryChange = (query: string): void => {
+    if (query !== this.state.query) {
+      this.autoNavigateQuery = null;
+    }
+    this.setState({ categories: [], moreResults: false, projects: [], query });
+    this.queueQuery(query);
+  };
+
+  private queueQuery(query: string): void {
+    const showMinLengthWarning = Boolean(query && query.length < MIN_SEARCH_LENGTH);
+    if (!query || showMinLengthWarning) {
+      this.autoNavigateQuery = null;
+      this.setState({ searching: false, showMinLengthWarning });
+      this.updateLocation(query);
+      this.updatePageTitle(query);
+      return;
+    }
+
+    this.setState({ searching: true, showMinLengthWarning: false });
+    this.query$.next(query);
+  }
+
+  private handleResults(query: string, resultSets: ISearchResultSet[]): void {
+    if (query !== this.state.query) {
+      return;
+    }
+
+    const allResults = resultSets.reduce(
+      (results, resultSet) => results.concat(resultSet.results),
+      [] as ISearchResult[],
+    );
+    if (this.autoNavigateQuery === query && allResults.length === 1) {
+      this.autoNavigateQuery = null;
+      this.navigateToResult(allResults[0].href);
+      return;
+    }
+    this.autoNavigateQuery = null;
+
+    const categories = resultSets
+      .filter(({ results, type }) => type.id !== 'projects' && results.length > 0)
+      .sort((a, b) => a.type.id.localeCompare(b.type.id));
+    const projects = resultSets.filter(({ results, type }) => type.id === 'projects' && results.length > 0);
+
+    this.setState({
+      categories,
+      moreResults: allResults.length === SearchService.DEFAULT_PAGE_SIZE,
+      projects,
+      searching: false,
+    });
+    this.updateLocation(query);
+    this.updatePageTitle(query);
+  }
+
+  private updateLocation(query: string): void {
+    this.props.stateService.go('.', { q: query || null, route: null }, { location: 'replace' });
+  }
+
+  private navigateToResult(href: string): void {
+    window.location.href = href;
+  }
+
+  private updatePageTitle(query: string): void {
+    this.props.deckRuntimeServices.pageTitleService.handleRoutingSuccess({
+      pageTitleMain: { field: undefined, label: query ? ` search results for "${query}"` : 'Infrastructure' },
+    });
+  }
+
+  private resultClicked = (result: ISearchResult): void => ClusterState.filterService.overrideFiltersForUrl(result);
+
+  private renderProjects(): React.ReactNode {
+    if (!this.state.projects.length) {
+      return null;
+    }
+
+    return (
+      <div className="col-md-3">
+        <h3>Projects</h3>
+        {this.state.projects[0].results.map((project: any) => (
+          <ProjectSummaryPod
+            key={project.id || project.name}
+            id={project.id || project.name}
+            projectName={project.name}
+            applications={project.config?.applications || []}
+            onResultClick={() => undefined}
+          />
+        ))}
+      </div>
+    );
+  }
+
+  private renderCategories(): React.ReactNode {
+    const { categories, projects, query } = this.state;
+    return (
+      <div className={`col-md-${projects.length ? 9 : 12}`}>
+        <h3>Results matching "{query}"</h3>
+        {!categories.length && <h4>No Infrastructure results found.</h4>}
+        <div className="row">
+          {categories.map((category) => (
+            <div className="col-md-4 category-container" key={category.type.id}>
+              <div className="panel category row">
+                <div className="summary">
+                  <span className="category-icon">
+                    {category.type.iconClass && <span className={category.type.iconClass} />}
+                  </span>
+                  {category.type.displayName} ({category.results.length})
+                </div>
+                <div className="details-container list-group">
+                  {searchRank(category.results, query).map((result, index) => (
+                    <a
+                      className="list-group-item"
+                      href={result.href}
+                      key={result.href || `${result.displayName}-${index}`}
+                      onClick={() => this.resultClicked(result)}
+                    >
+                      <SearchResult displayName={result.displayName} account={(result as any).account} />
+                    </a>
+                  ))}
+                </div>
+              </div>
+            </div>
+          ))}
+        </div>
+      </div>
+    );
+  }
+
+  public render(): React.ReactNode {
+    const { categories, moreResults, projects, query, searching, showMinLengthWarning } = this.state;
+    const hasResults = categories.length > 0 || projects.length > 0;
+    const showNoResults = !searching && query.length >= MIN_SEARCH_LENGTH && !hasResults;
+    const showRecentResults = !searching && !query;
+    const placeholder = `projects, applications, clusters, load balancers, server groups, ${FirewallLabels.get(
+      'firewalls',
+    )}`;
+
+    return (
+      <div className="infrastructure">
+        <div className="infrastructure-section search-header">
+          <div className="container">
+            <h2 className="header-section">
+              <i className="fa fa-search" />
+              <span className="search-label">Search</span>
+              <div className="flex-grow">
+                <input
+                  aria-label="Search infrastructure"
+                  autoFocus
+                  className="form-control input-lg"
+                  data-purpose="search-v1-input"
+                  onChange={(event) => this.handleQueryChange(event.target.value)}
+                  placeholder={placeholder}
+                  type="search"
+                  value={query}
+                />
+                {showMinLengthWarning && (
+                  <p data-purpose="search-v1-min-length" style={{ margin: '10px 20px 0', fontSize: '1.5rem' }}>
+                    Please enter at least {MIN_SEARCH_LENGTH} characters to begin searching.
+                  </p>
+                )}
+              </div>
+            </h2>
+            <div className="header-actions">
+              <InsightMenu createApp={true} createProject={true} refreshCaches={false} />
+            </div>
+          </div>
+        </div>
+
+        {hasResults && (
+          <div className="container">
+            {moreResults && <p style={{ margin: '10px 20px 0' }}>Only showing the first 500 results found.</p>}
+            <div className="row infrastructure-section">
+              {this.renderProjects()}
+              {this.renderCategories()}
+            </div>
+          </div>
+        )}
+
+        {searching && (
+          <div className="horizontal center middle flex-1" style={{ margin: '25px 0', height: '100%' }}>
+            <Spinner size="large" />
+          </div>
+        )}
+
+        {showNoResults && (
+          <div className="container">
+            <h4 className="no-results">No results matching "{query}".</h4>
+          </div>
+        )}
+
+        {showRecentResults && (
+          <div className="infrastructure-section container">
+            <RecentlyViewedItems Component={SearchResultPods} />
+          </div>
+        )}
+      </div>
+    );
+  }
+}
+
+export const SearchV1 = withDeckRuntimeServices(withRouter(SearchV1Component));

package/src/search/infrastructure/SearchV2.spec.tsx

@@ -0,0 +1,34 @@
+import { shallow } from 'enzyme';
+import React from 'react';
+import { BehaviorSubject } from 'rxjs';
+
+import { SearchV2Component } from './SearchV2';
+
+describe('SearchV2', () => {
+  const deckRuntimeServices = {
+    pageTitleService: { handleRoutingSuccess: jasmine.createSpy('handleRoutingSuccess') },
+  } as any;
+
+  it('uses injected route state for tab selection and filter navigation', () => {
+    const go = jasmine.createSpy('go');
+    const component = shallow(
+      <SearchV2Component
+        deckRuntimeServices={deckRuntimeServices}
+        router={{ globals: { params$: new BehaviorSubject({ tab: 'applications' }) } } as any}
+        stateParams={{ tab: 'applications' }}
+        stateService={{ go } as any}
+      />,
+      { disableLifecycleMethods: true },
+    );
+
+    expect(component.state('selectedTab')).toBe('applications');
+
+    (component.instance() as SearchV2Component).handleFilterChange([{ key: 'name', text: 'payments' } as any]);
+
+    expect(go).toHaveBeenCalledWith(
+      '.',
+      { account: undefined, key: undefined, name: 'payments', region: undefined, stack: undefined },
+      { location: 'replace' },
+    );
+  });
+});

package/src/search/infrastructure/SearchV2.tsx

@@ -3,6 +3,8 @@ import React from 'react';
 import type { Observable } from 'rxjs';
 import { empty as observableEmpty, Subject } from 'rxjs';
 import { distinctUntilChanged, map, scan, switchMap, takeUntil, tap } from 'rxjs/operators';
+import type { IDeckRuntimeServicesInjectedProps } from '../../bootstrap/DeckRuntimeContext';
+import { withDeckRuntimeServices } from '../../bootstrap/DeckRuntimeContext';
 
 import { RecentlyViewedItems } from '../infrastructure/RecentlyViewedItems';
 import { SearchResultPods } from '../infrastructure/SearchResultPods';
@@ -10,7 +12,8 @@ import type { ISearchResultSet } from '../infrastructure/infrastructureSearch.se
 import { InfrastructureSearchServiceV2 } from '../infrastructure/infrastructureSearchV2.service';
 import { InsightMenu } from '../../insight/InsightMenu';
 import type { IQueryParams } from '../../navigation';
-import { ReactInjector } from '../../reactShims';
+import type { IRouterInjectedProps } from '../../navigation/routerContext';
+import { withRouter } from '../../navigation/routerContext';
 import { SearchResults, searchResultTypeRegistry, SearchStatus } from '../searchResult';
 import type { ITag } from '../../widgets';
 import { Search } from '../widgets';
@@ -26,10 +29,9 @@ export interface ISearchV2State {
   refreshingCache: boolean;
 }
 
-export class SearchV2 extends React.Component<{}, ISearchV2State> {
-  private $state = ReactInjector.$state;
-  private $uiRouter = ReactInjector.$uiRouter;
+type SearchV2Props = IRouterInjectedProps & IDeckRuntimeServicesInjectedProps;
 
+export class SearchV2Component extends React.Component<SearchV2Props, ISearchV2State> {
   private searchResultTypes = searchResultTypeRegistry.getAll();
 
   private INITIAL_RESULTS: ISearchResultSet[] = this.searchResultTypes.map((type) => ({
@@ -40,11 +42,11 @@ export class SearchV2 extends React.Component<{}, ISearchV2State> {
 
   private destroy$ = new Subject();
 
-  constructor(props: {}) {
+  constructor(props: SearchV2Props) {
     super(props);
 
     this.state = {
-      selectedTab: this.$state.params.tab,
+      selectedTab: props.stateParams.tab,
       params: {},
       resultSets: this.INITIAL_RESULTS,
       isSearching: false,
@@ -52,7 +54,9 @@ export class SearchV2 extends React.Component<{}, ISearchV2State> {
     };
 
     // just set the page title - don't try to get fancy w/ the search terms
-    ReactInjector.pageTitleService.handleRoutingSuccess({ pageTitleMain: { field: undefined, label: 'Search' } });
+    props.deckRuntimeServices.pageTitleService.handleRoutingSuccess({
+      pageTitleMain: { field: undefined, label: 'Search' },
+    });
   }
 
   // returns parameter values that are OK to send through to the back end search API as filters
@@ -70,7 +74,7 @@ export class SearchV2 extends React.Component<{}, ISearchV2State> {
     // auto-navigation only happens via shortcut links, and we only do it if there is exactly one result, e.g
     // when searching for an instance ID
     const autoNavigate = window.location.href.endsWith('route=true');
-    this.$uiRouter.globals.params$
+    this.props.router.globals.params$
       .pipe(
         map((stateParams) => this.getApiFilterParams(stateParams)),
         tap((params: IQueryParams) => this.setState({ params })),
@@ -117,7 +121,7 @@ export class SearchV2 extends React.Component<{}, ISearchV2State> {
         () => this.setState({ isSearching: false }),
       );
 
-    this.$uiRouter.globals.params$
+    this.props.router.globals.params$
       .pipe(
         map((params) => params.tab),
         distinctUntilChanged(),
@@ -144,7 +148,7 @@ export class SearchV2 extends React.Component<{}, ISearchV2State> {
     );
 
     if (found.tabId) {
-      this.$state.go('.', { tab: found.tabId });
+      this.props.stateService.go('.', { tab: found.tabId });
     }
   }
 
@@ -155,7 +159,7 @@ export class SearchV2 extends React.Component<{}, ISearchV2State> {
   public handleFilterChange = (filters: ITag[]) => {
     const blankApiParams = API_PARAMS.reduce((acc, key) => ({ ...acc, [key]: undefined }), {});
     const newParams = filters.reduce((params, filter) => ({ ...params, [filter.key]: filter.text }), blankApiParams);
-    this.$state.go('.', newParams, { location: 'replace' });
+    this.props.stateService.go('.', newParams, { location: 'replace' });
   };
 
   public render() {
@@ -193,3 +197,5 @@ export class SearchV2 extends React.Component<{}, ISearchV2State> {
     );
   }
 }
+
+export const SearchV2 = withDeckRuntimeServices(withRouter(SearchV2Component));

package/src/search/infrastructure/infrastructure.states.spec.ts

@@ -0,0 +1,55 @@
+import { shallow } from 'enzyme';
+import React from 'react';
+import { UIRouterReact } from '@uirouter/react';
+
+import { createDeckRuntime } from '../../bootstrap/DeckRuntime';
+import { SETTINGS } from '../../config/settings';
+import { configureRouter } from '../../navigation/router';
+import { SpinErrorBoundary } from '../../presentation';
+import { SearchV1 } from './SearchV1';
+import { SearchV2 } from './SearchV2';
+
+import './infrastructure.states';
+
+describe('infrastructure states', () => {
+  const originalSearchVersion = SETTINGS.searchVersion;
+
+  function createRouter(): UIRouterReact {
+    const router = new UIRouterReact();
+    const runtime = createDeckRuntime(router);
+    router.disposable(runtime);
+    return configureRouter(router, runtime.services, runtime.routingState);
+  }
+
+  afterEach(() => {
+    SETTINGS.searchVersion = originalSearchVersion;
+  });
+
+  it('registers direct V1 search and its one-shot route parameter', () => {
+    SETTINGS.searchVersion = 1;
+    const router = createRouter();
+    const searchState = router.stateRegistry.get('home.search');
+    const view = searchState.views['main@'];
+    const errorBoundary = shallow(React.createElement(view.component));
+
+    expect(errorBoundary.type()).toBe(SpinErrorBoundary);
+    expect(errorBoundary.prop('children').type.displayName).toBe(SearchV1.displayName);
+    expect(view.$type).toBe('react');
+    expect(searchState.url).toContain('&route');
+    expect(searchState.params.route.dynamic).toBe(true);
+    router.dispose();
+  });
+
+  it('registers direct V2 search when configured', () => {
+    SETTINGS.searchVersion = 2;
+    const router = createRouter();
+    const searchState = router.stateRegistry.get('home.search');
+    const view = searchState.views['main@'];
+    const errorBoundary = shallow(React.createElement(view.component));
+
+    expect(errorBoundary.type()).toBe(SpinErrorBoundary);
+    expect(errorBoundary.prop('children').type.displayName).toBe(SearchV2.displayName);
+    expect(view.$type).toBe('react');
+    router.dispose();
+  });
+});

package/src/search/infrastructure/infrastructure.states.ts

@@ -1,45 +1,46 @@
-import { module } from 'angular';
+import { SearchV1 } from './SearchV1';
+import { SearchV2 } from './SearchV2';
 import { SETTINGS } from '../../config/settings';
+import { registerRootState } from '../../navigation/rootState.registration';
 import type { StateConfigProvider } from '../../navigation/state.provider';
-import { STATE_CONFIG_PROVIDER } from '../../navigation/state.provider';
 
-export const INFRASTRUCTURE_STATES = 'spinnaker.core.search.states';
-module(INFRASTRUCTURE_STATES, [STATE_CONFIG_PROVIDER]).config([
-  'stateConfigProvider',
-  (stateConfigProvider: StateConfigProvider) => {
-    stateConfigProvider.addToRootState({
-      name: 'search',
-      url: '/search?q&key&tab&name&account&region&stack',
-      params: {
-        account: { dynamic: true, value: null },
-        key: { dynamic: true, value: null },
-        name: { dynamic: true, value: null },
-        q: { dynamic: true, value: null },
-        region: { dynamic: true, value: null },
-        stack: { dynamic: true, value: null },
-        tab: { dynamic: true, value: null },
+function registerSearchStates(stateConfigProvider: StateConfigProvider): void {
+  stateConfigProvider.addToRootState({
+    name: 'search',
+    url: '/search?q&key&tab&name&account&region&stack&route',
+    params: {
+      account: { dynamic: true, value: null },
+      key: { dynamic: true, value: null },
+      name: { dynamic: true, value: null },
+      q: { dynamic: true, value: null },
+      region: { dynamic: true, value: null },
+      route: { dynamic: true, value: null },
+      stack: { dynamic: true, value: null },
+      tab: { dynamic: true, value: null },
+    },
+    views: {
+      'main@': {
+        component: SETTINGS.searchVersion === 2 ? SearchV2 : SearchV1,
+        $type: 'react',
       },
-      views: {
-        'main@': {
-          template: `
-          <infrastructure-search-v1 ng-if="$resolve.version == 1" class="flex-fill"></infrastructure-search-v1>
-          <infrastructure-search-v2 ng-if="$resolve.version == 2" class="flex-fill"></infrastructure-search-v2>
-        `,
-        },
+    },
+    data: {
+      pageTitleMain: {
+        label: 'Search',
       },
-      data: {
-        pageTitleMain: {
-          label: 'Search',
-        },
-      },
-      resolve: {
-        version: () => SETTINGS.searchVersion || 1,
-      },
-    });
+    },
+    resolve: {
+      version: () => SETTINGS.searchVersion || 1,
+    },
+  });
+
+  stateConfigProvider.addToRootState({ name: 'infrastructure', url: '/search?q', redirectTo: 'home.search' });
+  if (!stateConfigProvider.addRewriteRule) {
+    return;
+  }
+  stateConfigProvider.addRewriteRule('/infrastructure?q', '/search?q');
+  stateConfigProvider.addRewriteRule('', '/search');
+  stateConfigProvider.addRewriteRule('/', '/search');
+}
 
-    stateConfigProvider.addToRootState({ name: 'infrastructure', url: '/search?q', redirectTo: 'home.search' });
-    stateConfigProvider.addRewriteRule('/infrastructure?q', '/search?q');
-    stateConfigProvider.addRewriteRule('', '/search');
-    stateConfigProvider.addRewriteRule('/', '/search');
-  },
-]);
+registerRootState(registerSearchStates);

package/src/search/infrastructure/infrastructureSearch.service.ts

@@ -1,16 +1,14 @@
-import type { IDeferred, IQService } from 'angular';
-import { module } from 'angular';
 import { of as observableOf, Subject } from 'rxjs';
 import { switchMap, toArray } from 'rxjs/operators';
 
-import type { ProviderServiceDelegate } from '../../cloudProvider';
-import { PROVIDER_SERVICE_DELEGATE } from '../../cloudProvider';
-
+import type { ProviderServiceDelegate } from '../../cloudProvider/providerService.delegate';
 import { InfrastructureSearchServiceV2 } from './infrastructureSearchV2.service';
 import type { ISearchResult } from '../search.service';
-import type { SearchResultType } from '../searchResult';
-import { searchResultTypeRegistry } from '../searchResult';
 import { SearchStatus } from '../searchResult/SearchStatus';
+import type { SearchResultType } from '../searchResult/searchResultType';
+import { searchResultTypeRegistry } from '../searchResult/searchResultType.registry';
+import type { Deferred } from '../../utils/deferred';
+import { createDeferred } from '../../utils/deferred';
 
 export interface ISearchResultSet<T extends ISearchResult = ISearchResult> {
   type: SearchResultType;
@@ -26,10 +24,10 @@ export interface IProviderResultFormatter {
 }
 
 export class InfrastructureSearcher {
-  private deferred: IDeferred<ISearchResultSet[]>;
+  private deferred: Deferred<ISearchResultSet[]>;
   public querySubject: Subject<string> = new Subject<string>();
 
-  constructor(private $q: IQService, private providerServiceDelegate: ProviderServiceDelegate) {
+  constructor(private providerServiceDelegate: ProviderServiceDelegate) {
     this.querySubject
       .pipe(
         switchMap((query: string) => {
@@ -47,8 +45,8 @@ export class InfrastructureSearcher {
       });
   }
 
-  public query(q: string): PromiseLike<ISearchResultSet[]> {
-    this.deferred = this.$q.defer();
+  public query(q: string): Promise<ISearchResultSet[]> {
+    this.deferred = createDeferred<ISearchResultSet[]>();
     this.querySubject.next(q);
     return this.deferred.promise;
   }
@@ -57,14 +55,14 @@ export class InfrastructureSearcher {
     return searchResultTypeRegistry.get(category);
   }
 
-  public formatRouteResult(category: string, entry: ISearchResult): PromiseLike<string> {
+  public formatRouteResult(category: string, entry: ISearchResult): Promise<string> {
     return this.formatResult(category, entry, true);
   }
 
-  private formatResult(category: string, entry: ISearchResult, fromRoute = false): PromiseLike<string> {
+  private formatResult(category: string, entry: ISearchResult, fromRoute = false): Promise<string> {
     const type = searchResultTypeRegistry.get(category);
     if (!type) {
-      return this.$q.when('');
+      return Promise.resolve('');
     }
     let formatter: ISearchResultFormatter = type.displayFormatter;
 
@@ -76,21 +74,14 @@ export class InfrastructureSearcher {
         formatter = providerFormatter[category];
       }
     }
-    return this.$q.when(formatter(entry, fromRoute));
+    return Promise.resolve(formatter(entry, fromRoute));
   }
 }
 
 export class InfrastructureSearchService {
-  public static $inject = ['$q', 'providerServiceDelegate'];
-  constructor(private $q: IQService, private providerServiceDelegate: any) {}
+  constructor(private providerServiceDelegate: any) {}
 
   public getSearcher(): InfrastructureSearcher {
-    return new InfrastructureSearcher(this.$q, this.providerServiceDelegate);
+    return new InfrastructureSearcher(this.providerServiceDelegate);
   }
 }
-
-export const INFRASTRUCTURE_SEARCH_SERVICE = 'spinnaker.infrastructure.search.service';
-module(INFRASTRUCTURE_SEARCH_SERVICE, [PROVIDER_SERVICE_DELEGATE]).service(
-  'infrastructureSearchService',
-  InfrastructureSearchService,
-);

package/src/search/infrastructure/infrastructureSearchV2.service.spec.ts

@@ -0,0 +1,23 @@
+import { toArray } from 'rxjs/operators';
+
+import { searchResultTypeRegistry } from '../searchResult/searchResultType.registry';
+import type { SearchResultType } from '../searchResult/searchResultType';
+import { InfrastructureSearchServiceV2 } from './infrastructureSearchV2.service';
+
+describe('InfrastructureSearchServiceV2', () => {
+  it('reads empty-search result types when searching, not when the module loads', async () => {
+    const resultType = {
+      id: 'late-registered-type',
+      order: Number.MAX_SAFE_INTEGER,
+      displayName: 'Late Registered Type',
+      displayFormatter: () => 'Late Registered Type',
+      search: () => undefined,
+    } as SearchResultType;
+
+    searchResultTypeRegistry.register(resultType);
+
+    const results = await InfrastructureSearchServiceV2.search({}).pipe(toArray()).toPromise();
+
+    expect(results.some((result) => result.type.id === resultType.id)).toBe(true);
+  });
+});