@finos/legend-application-studio 28.18.124 → 28.18.126

package/src/stores/editor/EditorStore.ts

@@ -56,6 +56,7 @@ import {
   AssertionError,
   guaranteeType,
   type Clazz,
+  returnUndefOnError,
 } from '@finos/legend-shared';
 import { EditorSDLCState } from './EditorSDLCState.js';
 import { ModelImporterState } from './editor-state/ModelImporterState.js';
@@ -69,6 +70,8 @@ import {
   generateEditorRoute,
   generateSetupRoute,
   generateViewProjectRoute,
+  LEGEND_STUDIO_QUERY_PARAMS,
+  type StudioQueryParams,
   type WorkspaceEditorPathParams,
 } from '../../__lib__/LegendStudioNavigation.js';
 import { PanelDisplayState } from '@finos/legend-art';
@@ -118,6 +121,8 @@ import {
   LazyTextEditorStore,
 } from '../lazy-text-editor/LazyTextEditorStore.js';
 import type { QueryBuilderDataCubeViewerState } from '@finos/legend-query-builder';
+import { IngestionManager } from '../ingestion/IngestionManager.js';
+import { EditorInitialConfiguration } from './editor-state/element-editor-state/ElementEditorInitialConfiguration.js';
 
 export abstract class EditorExtensionState {
   /**
@@ -133,6 +138,7 @@ export class EditorStore implements CommandRegistrar {
   readonly applicationStore: LegendStudioApplicationStore;
   readonly sdlcServerClient: SDLCServerClient;
   readonly depotServerClient: DepotServerClient;
+  readonly ingestionManager: IngestionManager | undefined;
   readonly pluginManager: LegendStudioPluginManager;
 
   /**
@@ -145,6 +151,7 @@ export class EditorStore implements CommandRegistrar {
   readonly initState = ActionState.create();
 
   initialEntityPath?: string | undefined;
+  editorConfig: EditorInitialConfiguration | undefined;
   editorMode: EditorMode;
   // NOTE: once we clear up the editor store to make modes more separated
   // we should remove these sets of functions. They are basically hacks to
@@ -303,6 +310,16 @@ export class EditorStore implements CommandRegistrar {
       this,
       this.sdlcState,
     );
+    // ingestion
+    const ingestionConifg =
+      applicationStore.config.options.ingestDeploymentConfig;
+    if (ingestionConifg) {
+      this.ingestionManager = new IngestionManager(
+        ingestionConifg,
+        this.applicationStore,
+      );
+    }
+
     // extensions
     this.extensionStates = this.pluginManager
       .getApplicationPlugins()
@@ -549,17 +566,35 @@ export class EditorStore implements CommandRegistrar {
     this.explorerTreeState = new ExplorerTreeState(this);
   }
 
-  internalizeEntityPath(params: Partial<WorkspaceEditorPathParams>): void {
+  internalizeEntityPath(
+    params: Partial<WorkspaceEditorPathParams>,
+    studioParams: Partial<StudioQueryParams> | undefined,
+  ): void {
     const { projectId, entityPath } = params;
     const workspaceType = params.groupWorkspaceId
       ? WorkspaceType.GROUP
       : WorkspaceType.USER;
+    const editorConfig =
+      studioParams?.[LEGEND_STUDIO_QUERY_PARAMS.EDITOR_CONFIG];
     const workspaceId = guaranteeNonNullable(
       params.groupWorkspaceId ?? params.workspaceId,
       `Workspace/group workspace ID is not provided`,
     );
     if (entityPath) {
       this.initialEntityPath = entityPath;
+      if (editorConfig) {
+        const _config = returnUndefOnError(() =>
+          EditorInitialConfiguration.serialization.fromJson(
+            JSON.parse(atob(editorConfig)),
+          ),
+        );
+        const config = guaranteeNonNullable(
+          _config,
+          `error reading and serializing config ${editorConfig}`,
+        );
+
+        this.editorConfig = config;
+      }
       this.applicationStore.navigationService.navigator.updateCurrentLocation(
         generateEditorRoute(
           guaranteeNonNullable(projectId),
@@ -1031,7 +1066,10 @@ export class EditorStore implements CommandRegistrar {
         try {
           this.graphEditorMode.openElement(
             this.graphManagerState.graph.getElement(this.initialEntityPath),
+            this.editorConfig,
           );
+          // we may not want to set as undefined if using it for other things
+          this.editorConfig = undefined;
         } catch {
           const elementPath = this.initialEntityPath;
           this.initialEntityPath = undefined;

package/src/stores/editor/EditorTabManagerState.ts

@@ -36,6 +36,7 @@ import {
   SnowflakeApp,
   HostedService,
   DataProduct,
+  IngestDefinition,
 } from '@finos/legend-graph';
 import {
   type Clazz,
@@ -66,6 +67,8 @@ import { SnowflakeAppFunctionActivatorEdtiorState } from './editor-state/element
 import { HostedServiceFunctionActivatorEditorState } from './editor-state/element-editor-state/function-activator/HostedServiceFunctionActivatorEditorState.js';
 import { ArtifactGenerationViewerState } from './editor-state/ArtifactGenerationViewerState.js';
 import { DataProductEditorState } from './editor-state/element-editor-state/dataProduct/DataProductEditorState.js';
+import { IngestDefinitionEditorState } from './editor-state/element-editor-state/ingest/IngestDefinitionEditorState.js';
+import type { EditorInitialConfiguration } from './editor-state/element-editor-state/ElementEditorInitialConfiguration.js';
 
 export class EditorTabManagerState extends TabManagerState {
   readonly editorStore: EditorStore;
@@ -146,6 +149,7 @@ export class EditorTabManagerState extends TabManagerState {
 
   createElementEditorState(
     element: PackageableElement,
+    config?: EditorInitialConfiguration,
   ): ElementEditorState | undefined {
     if (element instanceof PrimitiveType) {
       throw new UnsupportedOperationError(
@@ -173,6 +177,8 @@ export class EditorTabManagerState extends TabManagerState {
       return new PackageableConnectionEditorState(this.editorStore, element);
     } else if (element instanceof Mapping) {
       return new MappingEditorState(this.editorStore, element);
+    } else if (element instanceof IngestDefinition) {
+      return new IngestDefinitionEditorState(this.editorStore, element, config);
     } else if (element instanceof Service) {
       return new ServiceEditorState(this.editorStore, element);
     } else if (element instanceof DataProduct) {

package/src/stores/editor/GraphEditFormModeState.ts

@@ -55,6 +55,7 @@ import { ElementEditorState } from './editor-state/element-editor-state/ElementE
 import { LegendStudioTelemetryHelper } from '../../__lib__/LegendStudioTelemetryHelper.js';
 import { GraphEditorMode } from './GraphEditorMode.js';
 import { GlobalBulkServiceRegistrationState } from './sidebar-state/BulkServiceRegistrationState.js';
+import type { EditorInitialConfiguration } from './editor-state/element-editor-state/ElementEditorInitialConfiguration.js';
 
 export class GraphEditFormModeState extends GraphEditorMode {
   *initialize(): GeneratorFn<void> {
@@ -567,7 +568,10 @@ export class GraphEditFormModeState extends GraphEditorMode {
     return;
   }
 
-  openElement(element: PackageableElement): void {
+  openElement(
+    element: PackageableElement,
+    config?: EditorInitialConfiguration | undefined,
+  ): void {
     if (!(element instanceof Package)) {
       const existingElementState = this.editorStore.tabManagerState.tabs.find(
         (state) =>
@@ -575,7 +579,10 @@ export class GraphEditFormModeState extends GraphEditorMode {
       );
       const newTab =
         existingElementState ??
-        this.editorStore.tabManagerState.createElementEditorState(element);
+        this.editorStore.tabManagerState.createElementEditorState(
+          element,
+          config,
+        );
       if (newTab) {
         this.editorStore.tabManagerState.openTab(newTab);
       } else {

package/src/stores/editor/GraphEditorMode.ts

@@ -22,6 +22,7 @@ import type { EditorStore } from './EditorStore.js';
 
 import type { GRAPH_EDITOR_MODE } from './EditorConfig.js';
 import type { Problem } from './EditorGraphState.js';
+import type { EditorInitialConfiguration } from './editor-state/element-editor-state/ElementEditorInitialConfiguration.js';
 
 export abstract class GraphEditorMode {
   readonly editorStore: EditorStore;
@@ -81,5 +82,8 @@ export abstract class GraphEditorMode {
     isGraphBuildFailure?: boolean;
   }): GeneratorFn<void>;
   abstract handleCleanupFailure(error: unknown): GeneratorFn<void>;
-  abstract openElement(element: PackageableElement): void;
+  abstract openElement(
+    element: PackageableElement,
+    config?: EditorInitialConfiguration | undefined,
+  ): void;
 }

package/src/stores/editor/editor-state/element-editor-state/ElementEditorInitialConfiguration.ts

@@ -0,0 +1,97 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  SerializationFactory,
+  UnsupportedOperationError,
+  usingConstantValueSchema,
+  type PlainObject,
+} from '@finos/legend-shared';
+import { PACKAGEABLE_ELEMENT_TYPE } from '../../utils/ModelClassifierUtils.js';
+import {
+  createModelSchema,
+  custom,
+  deserialize,
+  optional,
+  primitive,
+  serialize,
+} from 'serializr';
+
+export abstract class ElementEditorInitialConfiguration {
+  abstract type: PACKAGEABLE_ELEMENT_TYPE;
+}
+
+export class IngestElementEditorInitialConfiguration extends ElementEditorInitialConfiguration {
+  deployOnOpen?: boolean;
+  type = PACKAGEABLE_ELEMENT_TYPE.INGEST_DEFINITION;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(IngestElementEditorInitialConfiguration, {
+      _type: usingConstantValueSchema(
+        PACKAGEABLE_ELEMENT_TYPE.INGEST_DEFINITION,
+      ),
+      deployOnOpen: optional(primitive()),
+    }),
+  );
+}
+
+const serializeElementEditorInitialConfiguration = (
+  protocol: ElementEditorInitialConfiguration,
+): PlainObject<ElementEditorInitialConfiguration> => {
+  if (protocol instanceof IngestElementEditorInitialConfiguration) {
+    return serialize(
+      IngestElementEditorInitialConfiguration.serialization.schema,
+      protocol,
+    );
+  }
+  throw new UnsupportedOperationError(
+    `Can't serialize element config`,
+    protocol,
+  );
+};
+
+const deseralizeElementEditorInitialConfiguration = (
+  json: PlainObject<ElementEditorInitialConfiguration>,
+): ElementEditorInitialConfiguration => {
+  switch (json._type) {
+    case PACKAGEABLE_ELEMENT_TYPE.INGEST_DEFINITION:
+      return deserialize(
+        IngestElementEditorInitialConfiguration.serialization.schema,
+        json,
+      );
+    default: {
+      throw new UnsupportedOperationError(
+        `Can't deserialize element config`,
+        json,
+      );
+    }
+  }
+};
+
+export class EditorInitialConfiguration {
+  elementEditorConfiguration?: ElementEditorInitialConfiguration;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(EditorInitialConfiguration, {
+      elementEditorConfiguration: optional(
+        custom(
+          serializeElementEditorInitialConfiguration,
+          deseralizeElementEditorInitialConfiguration,
+        ),
+      ),
+    }),
+  );
+}

package/src/stores/editor/editor-state/element-editor-state/ElementEditorState.ts

@@ -36,6 +36,7 @@ import {
 import { DEFAULT_TAB_SIZE } from '@finos/legend-application';
 import type { ElementFileGenerationState } from './ElementFileGenerationState.js';
 import type { ElementXTSchemaGenerationState } from './ElementExternalFormatGenerationState.js';
+import type { EditorInitialConfiguration } from './ElementEditorInitialConfiguration.js';
 
 const generateMultiLineCommentForError = (
   message: string,
@@ -104,7 +105,11 @@ export abstract class ElementEditorState extends EditorState {
   textContent = '';
   isReadOnly = false;
 
-  constructor(editorStore: EditorStore, element: PackageableElement) {
+  constructor(
+    editorStore: EditorStore,
+    element: PackageableElement,
+    config?: EditorInitialConfiguration | undefined,
+  ) {
     super(editorStore);
 
     makeObservable(this, {

package/src/stores/editor/editor-state/element-editor-state/function-activator/SnowflakeAppFunctionActivatorEditorState.ts

@@ -48,6 +48,7 @@ export class SnowflakeAppFunctionActivatorEdtiorState extends ElementEditorState
       reprocess: action,
       updateOwnership: action,
       updateUsageRole: action,
+      updateDeploymentSchema: action,
       updatePermissionScopte: action,
       updateAppDescription: action,
       updateApplicationName: action,
@@ -88,6 +89,10 @@ export class SnowflakeAppFunctionActivatorEdtiorState extends ElementEditorState
     this.activator.usageRole = val;
   }
 
+  updateDeploymentSchema(val: string | undefined): void {
+    this.activator.deploymentSchema = val;
+  }
+
   updatePermissionScopte(val: SnowflakePermissionScheme): void {
     this.activator.permissionScheme = val;
   }

package/src/stores/editor/editor-state/element-editor-state/ingest/IngestDefinitionEditorState.ts

@@ -0,0 +1,184 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { IngestDefinition, type PackageableElement } from '@finos/legend-graph';
+import { ElementEditorState } from '../ElementEditorState.js';
+import type { EditorStore } from '../../../EditorStore.js';
+import {
+  ActionState,
+  assertErrorThrown,
+  assertTrue,
+  guaranteeNonNullable,
+  guaranteeType,
+  type GeneratorFn,
+} from '@finos/legend-shared';
+import type { IngestionManager } from '../../../../ingestion/IngestionManager.js';
+import { action, flow, flowResult, makeObservable, observable } from 'mobx';
+import type {
+  IngestDefinitionValidationResponse,
+  ValidateAndDeploymentResponse,
+} from '../../../../ingestion/IngestionDeploymentResponse.js';
+import {
+  EditorInitialConfiguration,
+  IngestElementEditorInitialConfiguration,
+} from '../ElementEditorInitialConfiguration.js';
+import type { AuthContextProps } from 'react-oidc-context';
+import { EXTERNAL_APPLICATION_NAVIGATION__generateUrlWithEditorConfig } from '../../../../../__lib__/LegendStudioNavigation.js';
+
+const createEditorInitialConfiguration = (): EditorInitialConfiguration => {
+  const config = new EditorInitialConfiguration();
+  const ingest = new IngestElementEditorInitialConfiguration();
+  ingest.deployOnOpen = true;
+  config.elementEditorConfiguration = ingest;
+  return config;
+};
+
+const editorInitialConfigToBase64 = (val: EditorInitialConfiguration): string =>
+  btoa(JSON.stringify(EditorInitialConfiguration.serialization.toJson(val)));
+
+export const generateUrlToDeployOnOpen = (
+  val: IngestDefinitionEditorState,
+): string => {
+  return val.editorStore.applicationStore.navigationService.navigator.generateAddress(
+    EXTERNAL_APPLICATION_NAVIGATION__generateUrlWithEditorConfig(
+      val.editorStore.editorMode.generateElementLink(val.ingest.path),
+      editorInitialConfigToBase64(createEditorInitialConfiguration()),
+    ),
+  );
+};
+export class IngestDefinitionEditorState extends ElementEditorState {
+  validationError: IngestDefinitionValidationResponse | undefined;
+  deploymentState = ActionState.create();
+  deployOnOpen = false;
+
+  constructor(
+    editorStore: EditorStore,
+    element: PackageableElement,
+    config?: EditorInitialConfiguration,
+  ) {
+    super(editorStore, element);
+
+    makeObservable(this, {
+      deploymentState: observable,
+      deployOnOpen: observable,
+      setDeployOnOpen: observable,
+      validationError: observable,
+      setValError: action,
+      init_with_deploy: flow,
+      deploy: flow,
+    });
+    const elementConfig = config?.elementEditorConfiguration;
+    if (elementConfig instanceof IngestElementEditorInitialConfiguration) {
+      this.deployOnOpen = elementConfig.deployOnOpen ?? false;
+    }
+  }
+
+  get ingestionManager(): IngestionManager | undefined {
+    return this.editorStore.ingestionManager;
+  }
+
+  setValError(val: IngestDefinitionValidationResponse | undefined): void {
+    this.validationError = val;
+  }
+
+  setDeployOnOpen(value: boolean): void {
+    this.deployOnOpen = value;
+  }
+
+  *init_with_deploy(auth: AuthContextProps): GeneratorFn<void> {
+    this.setDeployOnOpen(false);
+    if (!auth.isAuthenticated) {
+      auth
+        .signinRedirect({
+          state: generateUrlToDeployOnOpen(this),
+        })
+        .catch(this.editorStore.applicationStore.alertUnhandledError);
+      return;
+    }
+    const token = auth.user?.access_token;
+    yield flowResult(this.generateElementGrammar()).catch(
+      this.editorStore.applicationStore.alertUnhandledError,
+    );
+    flowResult(this.deploy(token)).catch(
+      this.editorStore.applicationStore.alertUnhandledError,
+    );
+  }
+
+  *deploy(token: string | undefined): GeneratorFn<void> {
+    try {
+      assertTrue(
+        this.validForDeployment,
+        'Ingest definition is not valid for deployment',
+      );
+      this.deploymentState.inProgress();
+      const response = (yield guaranteeNonNullable(
+        this.ingestionManager,
+      ).deploy(
+        guaranteeNonNullable(this.textContent),
+        guaranteeNonNullable(this.ingest.appDirDeployment),
+        this.deploymentState,
+        token,
+      )) as unknown as ValidateAndDeploymentResponse;
+      const deploymentResponse = response.deploymentResponse;
+      if (deploymentResponse) {
+        this.editorStore.applicationStore.notificationService.notifySuccess(
+          `Ingest definition successfully deployed on ${deploymentResponse.ingestDefinitionUrn}`,
+        );
+      } else {
+        this.setValError(response.validationResponse);
+      }
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.notificationService.notifyError(
+        `Ingest definition failed to deploy: ${error.message}`,
+      );
+    } finally {
+      this.deploymentState.complete();
+    }
+  }
+
+  reprocess(
+    newElement: PackageableElement,
+    editorStore: EditorStore,
+  ): ElementEditorState {
+    return new IngestDefinitionEditorState(editorStore, newElement);
+  }
+
+  get validForDeployment(): boolean {
+    return Boolean(
+      this.ingest.appDirDeployment && this.textContent && this.ingestionManager,
+    );
+  }
+
+  get validationMessage(): string {
+    if (!this.ingest.appDirDeployment) {
+      return 'No app dir deployment found';
+    } else if (!this.textContent) {
+      return 'No ingest definition found';
+    } else if (!this.ingestionManager) {
+      return 'No ingestion manager found';
+    }
+    return 'Deploy';
+  }
+
+  get ingest(): IngestDefinition {
+    return guaranteeType(
+      this.element,
+      IngestDefinition,
+      'Element inside ingest editor state must be a IngestDefinition',
+    );
+  }
+}

package/src/stores/editor/utils/ModelClassifierUtils.ts

@@ -76,6 +76,7 @@ export enum PACKAGEABLE_ELEMENT_TYPE {
 
   TEMPORARY__LOCAL_CONNECTION = 'LOCAL_CONNECTION',
   INTERNAL__UnknownElement = 'UNKNOWN',
+  INGEST_DEFINITION = 'INGEST_DEFINITION',
 }
 
 export enum PACKAGEABLE_ELEMENT_GROUP_BY_CATEGORY {

package/src/stores/ingestion/IngestDeploymentServerClient.ts

@@ -0,0 +1,83 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  AbstractServerClient,
+  ContentType,
+  HttpHeader,
+  type PlainObject,
+} from '@finos/legend-shared';
+import { makeObservable, observable } from 'mobx';
+import type {
+  IngestDefinitionDeploymentResponse,
+  IngestDefinitionValidationResponse,
+} from './IngestionDeploymentResponse.js';
+import type { IngestDeploymentServerConfig } from '../../application/LegendIngestionConfiguration.js';
+
+export class IngestDeploymentServerClient extends AbstractServerClient {
+  environmentClassification: string;
+  constructor(config: IngestDeploymentServerConfig) {
+    super({
+      baseUrl: config.ingestServerUrl,
+    });
+    this.environmentClassification = config.environmentClassification;
+    makeObservable(this, {
+      environmentClassification: observable,
+      baseUrl: observable,
+    });
+  }
+
+  private _token = (token?: string) => ({
+    Authorization: `Bearer ${token}`,
+  });
+
+  private _tokenWithTextPlain = (token?: string) => ({
+    [HttpHeader.CONTENT_TYPE]: ContentType.TEXT_PLAIN,
+    Authorization: `Bearer ${token}`,
+  });
+
+  private _ingest = (): string =>
+    `${this.baseUrl}/ingest/sdlc/deploy/definitions`;
+
+  changeServer(serverConfig: IngestDeploymentServerConfig): void {
+    this.baseUrl = serverConfig.ingestServerUrl;
+    this.environmentClassification = serverConfig.environmentClassification;
+  }
+
+  validate(
+    validateGrammar: string,
+    token: string | undefined,
+  ): Promise<PlainObject<IngestDefinitionValidationResponse>> {
+    return this.post(
+      `${this._ingest()}/validate`,
+      validateGrammar,
+      undefined,
+      this._tokenWithTextPlain(token),
+    );
+  }
+
+  deploy(
+    deployGrammar: string,
+    token: string | undefined,
+  ): Promise<IngestDefinitionDeploymentResponse> {
+    return this.post(
+      `${this._ingest()}`,
+      deployGrammar,
+      undefined,
+      this._tokenWithTextPlain(token),
+    );
+  }
+}

package/src/stores/ingestion/IngestDiscoveryServerClient.ts

@@ -0,0 +1,52 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { AbstractServerClient, type PlainObject } from '@finos/legend-shared';
+import type { IngestDeploymentServerConfig } from '../../application/LegendIngestionConfiguration.js';
+
+export class IngestDiscoveryServerClient extends AbstractServerClient {
+  constructor(url: string) {
+    super({
+      baseUrl: url,
+    });
+  }
+  private _ingest = (): string =>
+    `${this.baseUrl}/ingest/discovery/environments/producers`;
+
+  private _env = (): string => `${this.baseUrl}/ingest/discovery/environments`;
+
+  private _token = (token?: string) => ({
+    Authorization: `Bearer ${token}`,
+  });
+
+  discover(
+    token?: string | undefined,
+  ): Promise<PlainObject<IngestDeploymentServerConfig[]>> {
+    return this.get(`${this._env()}`, {}, this._token(token));
+  }
+
+  findProducerServer(
+    id: number,
+    level: string,
+    token?: string | undefined,
+  ): Promise<PlainObject<IngestDeploymentServerConfig>> {
+    return this.get(
+      `${this._ingest()}/${id}/${level}/search`,
+      {},
+      this._token(token),
+    );
+  }
+}