@spinnaker/core 2026.2.2 → 2026.3.0

package/src/pipeline/config/triggers/artifacts/helm-image/HelmImageArtifactEditor.tsx

@@ -1,169 +1,85 @@
 import { cloneDeep } from 'lodash';
 import React from 'react';
-import type { Option } from 'react-select';
 
-import { ArtifactService } from '../ArtifactService';
+import { ArtifactEditor } from '../ArtifactEditor';
 import { ArtifactTypePatterns } from '../../../../../artifact/ArtifactTypes';
 import type { IArtifact, IArtifactEditorProps, IArtifactKindConfig } from '../../../../../domain';
-import { TetheredCreatable, TetheredSelect } from '../../../../../presentation';
+import { singleFieldArtifactEditor } from '../singleFieldArtifactEditor';
 import { StageConfigField } from '../../../stages/common';
-import { Spinner } from '../../../../../widgets/spinners/Spinner';
+import { SpelText } from '../../../../../widgets/spelText/SpelText';
 
 const TYPE = 'helm/image';
 
-interface IHelmImageArtifactEditorState {
-  names: string[];
-  versions: Array<Option<string>>;
-  versionsLoading: boolean;
-  namesLoading: boolean;
-}
-
-class HelmImageEditor extends React.Component<IArtifactEditorProps, IHelmImageArtifactEditorState> {
-  public state: IHelmImageArtifactEditorState = {
-    names: [],
-    versions: [],
-    versionsLoading: true,
-    namesLoading: true,
-  };
-
-  // taken from https://github.com/semver/semver/issues/232
-  private SEMVER = new RegExp(
-    /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(-(0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(\.(0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*)?(\+[0-9a-zA-Z-]+(\.[0-9a-zA-Z-]+)*)?$/,
-  );
-
-  constructor(props: IArtifactEditorProps) {
-    super(props);
-    const { artifact } = this.props;
-    if (artifact.type !== TYPE) {
-      const clonedArtifact = cloneDeep(artifact);
-      clonedArtifact.type = TYPE;
-      props.onChange(clonedArtifact);
-    }
-
-    ArtifactService.getArtifactNames(TYPE, this.props.account.name).then(
-      (names) => {
-        this.setState({
-          names,
-          namesLoading: false,
-        });
-      },
-      () => {
-        this.setState({
-          names: [],
-          namesLoading: false,
-          versionsLoading: false,
-          versions: [],
-        });
-      },
-    );
-  }
-
-  public componentDidMount() {
-    const { artifact } = this.props;
-    if (artifact.name) {
-      this.getChartVersionOptions(artifact.name);
-    }
-  }
-
-  public componentDidUpdate(prevProps: IArtifactEditorProps) {
-    if (this.props.account.name !== prevProps.account.name) {
-      ArtifactService.getArtifactNames(TYPE, this.props.account.name).then(
-        (names) => {
-          this.setState({
-            names,
-            namesLoading: false,
-            versions: [],
-          });
-        },
-        () => {
-          this.setState({
-            names: [],
-            namesLoading: false,
-            versions: [],
-          });
-        },
-      );
-    }
+const setNameAndVersionFromReference = (artifact: IArtifact) => {
+  const ref = artifact.reference;
+  if (ref == null) {
+    return artifact;
   }
 
-  public render() {
-    const { artifact } = this.props;
-    const nameOptions = this.state.names.map((name) => ({ value: name, label: name }));
+  const atIndex = ref.indexOf('@');
+  const lastColonIndex = ref.lastIndexOf(':');
 
-    return (
-      <>
-        <StageConfigField label="Name">
-          {!this.state.namesLoading && (
-            <TetheredSelect
-              options={nameOptions}
-              value={artifact.name || ''}
-              onChange={(e: Option) => {
-                this.onChange(e, 'name');
-                this.getChartVersionOptions(e.value.toString());
-              }}
-              clearable={false}
-            />
-          )}
-          {this.state.namesLoading && <Spinner />}
-        </StageConfigField>
-        <StageConfigField label="Version">
-          {!this.state.versionsLoading && (
-            <TetheredCreatable
-              options={this.state.versions}
-              value={artifact.version || ''}
-              onChange={(e: Option) => {
-                this.onChange(e, 'version');
-              }}
-              clearable={false}
-            />
-          )}
-          {this.state.versionsLoading && <Spinner />}
-        </StageConfigField>
-      </>
-    );
-  }
-
-  private onChange = (e: Option, field: keyof IArtifact) => {
-    const clone = cloneDeep(this.props.artifact);
-    (clone[field] as any) = e.value.toString();
-    this.props.onChange(clone);
-  };
-
-  private getChartVersionOptions(chartName: string) {
-    const { artifact, account } = this.props;
-    this.setState({ versionsLoading: true });
-    ArtifactService.getArtifactVersions(TYPE, account.name, chartName).then((versions: string[]) => {
-      // if the version doesn't match SEMVER we assume that it's a regular expression or SpEL expression
-      // and add it to the list of valid versions
-      if (artifact.version && !this.SEMVER.test(artifact.version)) {
-        versions = versions.concat(artifact.version);
-      }
-      this.setState({
-        versions: versions.map((v) => ({ label: v, value: v })),
-        versionsLoading: false,
-      });
-    });
+  if (atIndex >= 0) {
+    const split = ref.split('@');
+    artifact.name = split[0];
+    artifact.version = split[1];
+  } else if (lastColonIndex > 0) {
+    artifact.name = ref.substring(0, lastColonIndex);
+    artifact.version = ref.substring(lastColonIndex + 1);
+  } else {
+    artifact.name = ref;
   }
-}
+  return artifact;
+};
 
 export const HelmImageMatch: IArtifactKindConfig = {
-  label: 'Helm',
+  label: 'Docker Image (OCI)',
   typePattern: ArtifactTypePatterns.HELM_IMAGE,
   type: TYPE,
   isDefault: false,
   isMatch: true,
-  description: 'A helm chart to be deployed',
-  key: 'helm',
-  editCmp: HelmImageEditor,
+  description: 'A Docker image stored in an OCI registry.',
+  key: 'helm-image',
+  editCmp: singleFieldArtifactEditor(
+    'name',
+    TYPE,
+    'Docker image',
+    'gcr.io/project/image',
+    'pipeline.config.expectedArtifact.docker.name',
+  ),
 };
 
 export const HelmImageDefault: IArtifactKindConfig = {
-  label: 'Helm',
+  label: 'Docker Image (OCI)',
   typePattern: ArtifactTypePatterns.HELM_IMAGE,
   type: TYPE,
   isDefault: true,
   isMatch: false,
-  description: 'A helm chart to be deployed',
-  key: 'default.helm',
-  editCmp: HelmImageEditor,
+  description: 'A Docker image stored in an OCI registry.',
+  key: 'default.helm-image',
+  editCmp: class extends ArtifactEditor {
+    constructor(props: IArtifactEditorProps) {
+      super(props, TYPE);
+    }
+
+    private onReferenceChanged = (reference: string) => {
+      const clonedArtifact = cloneDeep(this.props.artifact);
+      clonedArtifact.reference = reference;
+      this.props.onChange(setNameAndVersionFromReference(clonedArtifact));
+    };
+
+    public render() {
+      return (
+        <StageConfigField label="Object path" helpKey="pipeline.config.expectedArtifact.defaultDocker.reference">
+          <SpelText
+            placeholder="gcr.io/project/image@sha256:9efcc2818c9..."
+            value={this.props.artifact.reference}
+            onChange={this.onReferenceChanged}
+            pipeline={this.props.pipeline}
+            docLink={true}
+          />
+        </StageConfigField>
+      );
+    }
+  },
 };

package/src/pipeline/config/triggers/baseBuild/BaseBuildTriggerTemplate.tsx

@@ -1,5 +1,4 @@
 import { capitalize, get } from 'lodash';
-import { $q } from 'ngimport';
 import React from 'react';
 import type { Option } from 'react-select';
 import { from as observableFrom, Subject } from 'rxjs';
@@ -34,8 +33,8 @@ export class BaseBuildTriggerTemplate extends React.Component<
 > {
   private destroy$ = new Subject();
 
-  public static formatLabel(trigger: IBuildTrigger): PromiseLike<string> {
-    return $q.when(`(${capitalize(trigger.type)}) ${trigger.master}: ${trigger.job}`);
+  public static formatLabel(trigger: IBuildTrigger): Promise<string> {
+    return Promise.resolve(`(${capitalize(trigger.type)}) ${trigger.master}: ${trigger.job}`);
   }
 
   public constructor(props: IBaseBuildTriggerTemplateProps) {

package/src/pipeline/config/triggers/concourse/concourse.service.ts

@@ -1,19 +1,19 @@
 import { REST } from '../../../../api/ApiService';
 
 export class ConcourseService {
-  public static listTeamsForMaster(master: string): PromiseLike<string[]> {
+  public static listTeamsForMaster(master: string): Promise<string[]> {
     return REST('/concourse').path(master, 'teams').get();
   }
 
-  public static listPipelinesForTeam(master: string, team: string): PromiseLike<string[]> {
+  public static listPipelinesForTeam(master: string, team: string): Promise<string[]> {
     return REST('/concourse').path(master, 'teams', team, 'pipelines').get();
   }
 
-  public static listJobsForPipeline(master: string, team: string, pipeline: string): PromiseLike<string[]> {
+  public static listJobsForPipeline(master: string, team: string, pipeline: string): Promise<string[]> {
     return REST('/concourse').path(master, 'teams', team, 'pipelines', pipeline, 'jobs').get();
   }
 
-  public static listResourcesForPipeline(master: string, team: string, pipeline: string): PromiseLike<string[]> {
+  public static listResourcesForPipeline(master: string, team: string, pipeline: string): Promise<string[]> {
     return REST('/concourse').path(master, 'teams', team, 'pipelines', pipeline, 'resources').get();
   }
 }

package/src/pipeline/config/triggers/helm/HelmManualTriggerConfig.tsx

@@ -1,4 +1,3 @@
-import { $q } from 'ngimport';
 import React from 'react';
 
 import type { IHelmTriggerTemplateState } from './HelmTriggerTemplate';
@@ -33,8 +32,8 @@ const HelmManualTriggerConfig = (props: ITriggerTemplateComponentProps) => {
   );
 };
 
-HelmManualTriggerConfig.formatLabel = (trigger: IHelmTrigger): PromiseLike<string> => {
-  return $q.when(`(Helm) ${trigger.account ? trigger.account + ':' : ''}${trigger.chart || ''}`);
+HelmManualTriggerConfig.formatLabel = (trigger: IHelmTrigger): Promise<string> => {
+  return Promise.resolve(`(Helm) ${trigger.account ? trigger.account + ':' : ''}${trigger.chart || ''}`);
 };
 
 export { HelmManualTriggerConfig };

package/src/pipeline/config/triggers/nexus/nexusReader.service.ts

@@ -1,7 +1,7 @@
 import { REST } from '../../../../api/ApiService';
 
 export class NexusReaderService {
-  public static getNexusNames(): PromiseLike<string[]> {
+  public static getNexusNames(): Promise<string[]> {
     return REST('/nexus/names').get();
   }
 }

package/src/pipeline/config/triggers/pipeline/PipelineTriggerTemplate.spec.tsx

@@ -1,9 +1,10 @@
 import { mount, shallow } from 'enzyme';
 import React from 'react';
 
-import { PipelineTriggerTemplate } from './PipelineTriggerTemplate';
+import { PipelineTriggerTemplateComponent } from './PipelineTriggerTemplate';
+import type { DeckRuntimeServices } from '../../../../bootstrap';
+import { SETTINGS } from '../../../../config/settings';
 import type { IExecution, IPipelineCommand, IPipelineTrigger } from '../../../../domain';
-import { ReactInjector } from '../../../../reactShims';
 import { ExecutionsTransformer } from '../../../service/ExecutionsTransformer';
 
 /**
@@ -19,6 +20,16 @@ describe('<PipelineTriggerTemplate />', () => {
   let getExecutionsForConfigIdsSpy: jasmine.Spy;
   let addBuildInfoSpy: jasmine.Spy;
 
+  class PipelineTriggerTemplate extends PipelineTriggerTemplateComponent {
+    public static defaultProps = {
+      deckRuntimeServices: ({
+        executionService: {
+          getExecutionsForConfigIds: (...args: unknown[]) => getExecutionsForConfigIdsSpy(...args),
+        },
+      } as unknown) as DeckRuntimeServices,
+    };
+  }
+
   // Higher buildNumber = older execution (used for buildTime calculation)
   const createExecution = (id: string, buildNumber: number, overrides: Partial<IExecution> = {}): IExecution =>
     ({
@@ -74,10 +85,6 @@ describe('<PipelineTriggerTemplate />', () => {
 
   beforeEach(() => {
     getExecutionsForConfigIdsSpy = jasmine.createSpy('getExecutionsForConfigIds');
-    // ReactInjector.executionService is a getter, not a method - use spyOnProperty
-    spyOnProperty(ReactInjector, 'executionService', 'get').and.returnValue({
-      getExecutionsForConfigIds: getExecutionsForConfigIdsSpy,
-    });
     addBuildInfoSpy = spyOn(ExecutionsTransformer, 'addBuildInfo');
     updateCommandSpy.calls.reset();
   });
@@ -443,6 +450,87 @@ describe('<PipelineTriggerTemplate />', () => {
     });
   });
 
+  describe('Configurable execution option limit (SETTINGS.maxPipelineTriggerExecutionOptions)', () => {
+    const originalLimit = SETTINGS.maxPipelineTriggerExecutionOptions;
+
+    afterEach(() => {
+      SETTINGS.maxPipelineTriggerExecutionOptions = originalLimit;
+    });
+
+    it('defaults to 20 when no override is configured', async () => {
+      expect(SETTINGS.maxPipelineTriggerExecutionOptions).toBe(20);
+
+      getExecutionsForConfigIdsSpy.and.returnValue(Promise.resolve([]));
+
+      const trigger = createPipelineTrigger('source-pipeline-id');
+      const command = createCommand(trigger);
+
+      shallow(<PipelineTriggerTemplate command={command} updateCommand={updateCommandSpy} />);
+
+      await Promise.resolve();
+
+      expect(getExecutionsForConfigIdsSpy).toHaveBeenCalledWith(['source-pipeline-id'], { limit: 20 });
+    });
+
+    it('passes the configured override through to getExecutionsForConfigIds', async () => {
+      SETTINGS.maxPipelineTriggerExecutionOptions = 5;
+      getExecutionsForConfigIdsSpy.and.returnValue(Promise.resolve([]));
+
+      const trigger = createPipelineTrigger('source-pipeline-id');
+      const command = createCommand(trigger);
+
+      shallow(<PipelineTriggerTemplate command={command} updateCommand={updateCommandSpy} />);
+
+      await Promise.resolve();
+
+      expect(getExecutionsForConfigIdsSpy).toHaveBeenCalledWith(['source-pipeline-id'], { limit: 5 });
+    });
+
+    it('renders exactly as many dropdown options as executions returned under a custom limit', async () => {
+      SETTINGS.maxPipelineTriggerExecutionOptions = 2;
+      // Simulate the backend honoring the overridden limit by returning only 2 executions,
+      // even though 3 exist for this pipeline in these specs (execution1/2/3).
+      const executions = [execution1, execution2];
+      getExecutionsForConfigIdsSpy.and.returnValue(Promise.resolve(executions));
+
+      const trigger = createPipelineTrigger('source-pipeline-id');
+      const command = createCommand(trigger);
+
+      const wrapper = shallow(<PipelineTriggerTemplate command={command} updateCommand={updateCommandSpy} />);
+
+      await Promise.resolve();
+      wrapper.update();
+
+      expect(getExecutionsForConfigIdsSpy).toHaveBeenCalledWith(['source-pipeline-id'], { limit: 2 });
+      const options = wrapper.find('TetheredSelect').prop('options') as Array<{ value: string }>;
+      expect(options.length).toBe(2);
+      expect(options.map((o) => o.value)).toEqual(['exec-1', 'exec-2']);
+    });
+
+    it('re-reads the current SETTINGS value on every re-initialization (source pipeline change)', async () => {
+      getExecutionsForConfigIdsSpy.and.returnValue(Promise.resolve([]));
+
+      const trigger = createPipelineTrigger('source-pipeline-id');
+      const command = createCommand(trigger);
+
+      const wrapper = mount(<PipelineTriggerTemplate command={command} updateCommand={updateCommandSpy} />);
+      await Promise.resolve();
+
+      expect(getExecutionsForConfigIdsSpy).toHaveBeenCalledWith(['source-pipeline-id'], { limit: 20 });
+      getExecutionsForConfigIdsSpy.calls.reset();
+
+      // Operator changes the setting at runtime (e.g. via settings-local.js hot-reload in dev,
+      // or simply because a later test/session picked a different value) - the NEXT fetch
+      // triggered by switching source pipelines should honor the new value immediately.
+      SETTINGS.maxPipelineTriggerExecutionOptions = 7;
+      const newTrigger = createPipelineTrigger('different-pipeline-id');
+      const newCommand = createCommand(newTrigger);
+      wrapper.setProps({ command: newCommand });
+
+      expect(getExecutionsForConfigIdsSpy).toHaveBeenCalledWith(['different-pipeline-id'], { limit: 7 });
+    });
+  });
+
   describe('Async behavior', () => {
     // TODO: Fix potential race condition - if user switches pipelines while a request is loading,
     // the old request can return after the new one and show the wrong executions.

package/src/pipeline/config/triggers/pipeline/PipelineTriggerTemplate.tsx

@@ -1,12 +1,14 @@
 import { get, has } from 'lodash';
 import React from 'react';
 import type { Option } from 'react-select';
+import type { IDeckRuntimeServicesInjectedProps } from '../../../../bootstrap/DeckRuntimeContext';
+import { withDeckRuntimeServices } from '../../../../bootstrap/DeckRuntimeContext';
 
+import { SETTINGS } from '../../../../config/settings';
 import type { IExecution, IPipeline, IPipelineCommand, IPipelineTrigger } from '../../../../domain';
 import { ExecutionBuildTitle } from '../../../executionBuild/ExecutionBuildTitle';
 import type { ITriggerTemplateComponentProps } from '../../../manualExecution/TriggerTemplate';
 import { TetheredSelect } from '../../../../presentation/TetheredSelect';
-import { ReactInjector } from '../../../../reactShims';
 import { ExecutionsTransformer } from '../../../service/ExecutionsTransformer';
 import { PipelineConfigService } from '../../services/PipelineConfigService';
 import { timestamp } from '../../../../utils/timeFormatters';
@@ -19,11 +21,11 @@ export interface IPipelineTriggerTemplateState {
   selectedExecution: string;
 }
 
-export class PipelineTriggerTemplate extends React.Component<
-  ITriggerTemplateComponentProps,
+export class PipelineTriggerTemplateComponent extends React.Component<
+  ITriggerTemplateComponentProps & IDeckRuntimeServicesInjectedProps,
   IPipelineTriggerTemplateState
 > {
-  public static formatLabel(trigger: IPipelineTrigger): PromiseLike<string> {
+  public static formatLabel(trigger: IPipelineTrigger): Promise<string> {
     // if this is a re-run, the trigger info will be on the parentExecution; otherwise, check the trigger itself
     // (normalization occurs in the pipelineTriggerOptions component, but that renders after this method is called)
     const application = get(trigger, 'parentExecution.application', trigger.application);
@@ -41,7 +43,7 @@ export class PipelineTriggerTemplate extends React.Component<
     return PipelineConfigService.getPipelinesForApplication(application).then(loadSuccess, loadFailure);
   }
 
-  public constructor(props: ITriggerTemplateComponentProps) {
+  public constructor(props: ITriggerTemplateComponentProps & IDeckRuntimeServicesInjectedProps) {
     super(props);
     this.state = {
       executions: [],
@@ -75,8 +77,8 @@ export class PipelineTriggerTemplate extends React.Component<
       return;
     }
 
-    ReactInjector.executionService
-      .getExecutionsForConfigIds([trigger.pipeline], { limit: 20 })
+    this.props.deckRuntimeServices.executionService
+      .getExecutionsForConfigIds([trigger.pipeline], { limit: SETTINGS.maxPipelineTriggerExecutionOptions })
       .then(this.executionLoadSuccess, this.executionLoadFailure);
   };
 
@@ -211,3 +213,7 @@ export class PipelineTriggerTemplate extends React.Component<
     );
   }
 }
+
+export const PipelineTriggerTemplate = Object.assign(withDeckRuntimeServices(PipelineTriggerTemplateComponent), {
+  formatLabel: PipelineTriggerTemplateComponent.formatLabel,
+});

package/src/pipeline/config/validation/PipelineConfigValidator.ts

@@ -1,6 +1,5 @@
 import type { FormikErrors } from 'formik';
 import { flatten, isEmpty, isNumber, values } from 'lodash';
-import { $log, $q } from 'ngimport';
 import type { Subscription } from 'rxjs';
 import { Subject } from 'rxjs';
 
@@ -13,6 +12,7 @@ import type {
   ITriggerTypeConfig,
 } from '../../../domain';
 import { Registry } from '../../../registry';
+import { diagnosticLogger } from '../../../utils/diagnosticLogger';
 
 export interface IStageValidationResults {
   stage: IStage;
@@ -66,10 +66,10 @@ export class PipelineConfigValidator {
     this.validators.set(type, validator);
   }
 
-  public static validatePipeline(pipeline: IPipeline): PromiseLike<IPipelineValidationResults> {
+  public static validatePipeline(pipeline: IPipeline): Promise<IPipelineValidationResults> {
     const stages: IStage[] = pipeline.stages || [];
     const triggers: ITrigger[] = pipeline.triggers || [];
-    const validations: Array<PromiseLike<void>> = [];
+    const validations: Array<Promise<void>> = [];
     const pipelineValidations: string[] = this.getPipelineLevelValidations(pipeline);
     const stageValidations: Map<IStage, string[]> = new Map();
     let preventSave = false;
@@ -80,14 +80,14 @@ export class PipelineConfigValidator {
         config.validators.forEach((validator) => {
           const typedValidator = this.getValidator(validator);
           if (!typedValidator) {
-            $log.warn(
+            diagnosticLogger.warn(
               `No validator of type "${validator.type}" found, ignoring validation on trigger "${index + 1}" (${
                 trigger.type
               })`,
             );
           } else {
             validations.push(
-              $q.resolve<string>(typedValidator.validate(pipeline, trigger, validator, config)).then((message) => {
+              Promise.resolve(typedValidator.validate(pipeline, trigger, validator, config)).then((message) => {
                 if (message && !pipelineValidations.includes(message)) {
                   pipelineValidations.push(message);
                   if (validator.preventSave) {
@@ -100,13 +100,13 @@ export class PipelineConfigValidator {
         });
       } else if (config && config.validateFn) {
         validations.push(
-          $q<FormikErrors<IStage>>((resolve, reject) =>
-            Promise.resolve(config.validateFn(trigger, { pipeline })).then(resolve, reject),
-          ).then((errors: FormikErrors<ITrigger>) => {
-            PipelineConfigValidator.flattenValues(errors).forEach((message) => {
-              pipelineValidations.push(message);
-            });
-          }),
+          Promise.resolve()
+            .then(() => config.validateFn(trigger, { pipeline }))
+            .then((errors: FormikErrors<ITrigger>) => {
+              PipelineConfigValidator.flattenValues(errors).forEach((message) => {
+                pipelineValidations.push(message);
+              });
+            }),
         );
       }
     });
@@ -119,39 +119,37 @@ export class PipelineConfigValidator {
           }
           const typedValidator = this.getValidator(validator);
           if (!typedValidator) {
-            $log.warn(
+            diagnosticLogger.warn(
               `No validator of type "${validator.type}" found, ignoring validation on stage "${stage.name}" (${stage.type})`,
             );
           } else {
             validations.push(
-              $q
-                .resolve<string>(typedValidator.validate(pipeline, stage, validator, config))
-                .then((message: string) => {
-                  if (message) {
-                    if (!stageValidations.has(stage)) {
-                      stageValidations.set(stage, [] as string[]);
-                    }
-                    if (!stageValidations.get(stage).includes(message)) {
-                      stageValidations.get(stage).push(message);
-                      if (validator.preventSave) {
-                        preventSave = true;
-                      }
+              Promise.resolve(typedValidator.validate(pipeline, stage, validator, config)).then((message: string) => {
+                if (message) {
+                  if (!stageValidations.has(stage)) {
+                    stageValidations.set(stage, [] as string[]);
+                  }
+                  if (!stageValidations.get(stage).includes(message)) {
+                    stageValidations.get(stage).push(message);
+                    if (validator.preventSave) {
+                      preventSave = true;
                     }
                   }
-                }),
+                }
+              }),
             );
           }
         });
       } else if (config && config.validateFn) {
         validations.push(
-          $q<FormikErrors<IStage>>((resolve, reject) =>
-            Promise.resolve(config.validateFn(stage, { pipeline })).then(resolve, reject),
-          ).then((errors: FormikErrors<IStage>) => {
-            const array: string[] = PipelineConfigValidator.flattenValues(errors);
-            if (array && array.length > 0) {
-              stageValidations.set(stage, array);
-            }
-          }),
+          Promise.resolve()
+            .then(() => config.validateFn(stage, { pipeline }))
+            .then((errors: FormikErrors<IStage>) => {
+              const array: string[] = PipelineConfigValidator.flattenValues(errors);
+              if (array && array.length > 0) {
+                stageValidations.set(stage, array);
+              }
+            }),
         );
       }
 
@@ -163,7 +161,7 @@ export class PipelineConfigValidator {
       }
     });
 
-    return $q.all(validations).then(() => {
+    return Promise.all(validations).then(() => {
       const results = {
         stages: Array.from(stageValidations).map(([stage, messages]) => ({ stage, messages })),
         pipeline: pipelineValidations,