@finos/legend-application-studio 28.18.123 → 28.18.125

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/ingest/IngestDefinitionEditorState.ts

@@ -0,0 +1,169 @@
+/**
+ * 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 { flow, flowResult, makeObservable, observable } from 'mobx';
+import type { IngestDefinitionDeploymentResponse } 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 {
+  deploymentState = ActionState.create();
+  deployOnOpen = false;
+
+  constructor(
+    editorStore: EditorStore,
+    element: PackageableElement,
+    config?: EditorInitialConfiguration,
+  ) {
+    super(editorStore, element);
+
+    makeObservable(this, {
+      deploymentState: observable,
+      deployOnOpen: observable,
+      setDeployOnOpen: observable,
+      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;
+  }
+
+  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 IngestDefinitionDeploymentResponse;
+      this.editorStore.applicationStore.notificationService.notifySuccess(
+        `Ingest definition successfully deployed on ${response.ingestDefinitionUrn}`,
+      );
+    } 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),
+    );
+  }
+}

package/src/stores/ingestion/IngestionDeploymentResponse.ts

@@ -0,0 +1,45 @@
+/**
+ * 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 } from '@finos/legend-shared';
+import { createModelSchema, primitive } from 'serializr';
+
+export enum IngestDefinitionValidationResponseStatus {
+  NOT_CHECKED = 'NOT_CHECKED',
+  SUCCESS = 'SUCCESS',
+  FAILURE = 'FAILURE',
+}
+
+// TODO: include full response for user
+export class IngestDefinitionValidationResponse {
+  status!: IngestDefinitionValidationResponseStatus;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(IngestDefinitionValidationResponse, {
+      status: primitive(),
+    }),
+  );
+}
+
+export class IngestDefinitionDeploymentResponse {
+  ingestDefinitionUrn!: string;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(IngestDefinitionDeploymentResponse, {
+      ingestDefinitionUrn: primitive(),
+    }),
+  );
+}

package/src/stores/ingestion/IngestionManager.ts

@@ -0,0 +1,151 @@
+/**
+ * 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 type { AppDirNode } from '@finos/legend-graph';
+import { IngestDeploymentServerClient } from './IngestDeploymentServerClient.js';
+import { IngestDiscoveryServerClient } from './IngestDiscoveryServerClient.js';
+import type { GenericLegendApplicationStore } from '@finos/legend-application';
+import { type ActionState, type PlainObject } from '@finos/legend-shared';
+import {
+  IngestDefinitionValidationResponse,
+  IngestDefinitionDeploymentResponse,
+  IngestDefinitionValidationResponseStatus,
+} from './IngestionDeploymentResponse.js';
+import {
+  IngestDeploymentServerConfig,
+  type LegendIngestionConfiguration,
+} from '../../application/LegendIngestionConfiguration.js';
+
+export class IngestionManager {
+  private ingestDiscoveryServerClient: IngestDiscoveryServerClient;
+  private ingestDeploymentServerClient: IngestDeploymentServerClient;
+  private _currentAppID: number | undefined;
+  private _currentLevel: string | undefined;
+  private readonly applicationStore: GenericLegendApplicationStore;
+
+  constructor(
+    config: LegendIngestionConfiguration,
+    applicationStore: GenericLegendApplicationStore,
+  ) {
+    this.ingestDiscoveryServerClient = new IngestDiscoveryServerClient(
+      config.discoveryUrl,
+    );
+    this.ingestDiscoveryServerClient.setTracerService(
+      applicationStore.tracerService,
+    );
+    this.ingestDeploymentServerClient = new IngestDeploymentServerClient(
+      config.deployment.defaultServer,
+    );
+    this.ingestDeploymentServerClient.setTracerService(
+      applicationStore.tracerService,
+    );
+    this.applicationStore = applicationStore;
+  }
+
+  isCurrentAppDirNode(appDirNode: AppDirNode): boolean {
+    return (
+      this._currentAppID === appDirNode.appDirId &&
+      this._currentLevel === appDirNode.level
+    );
+  }
+
+  setCurrentAppDirNode(appDirNode: AppDirNode): void {
+    this._currentAppID = appDirNode.appDirId;
+    this._currentLevel = appDirNode.level;
+  }
+
+  async deploy(
+    ingestDefinition: string,
+    appDirNode: AppDirNode,
+    actionState: ActionState | undefined,
+    token: string | undefined,
+  ): Promise<IngestDefinitionDeploymentResponse> {
+    actionState?.setMessage(
+      `Discovering associated ingest environment for DID ${appDirNode.appDirId}...`,
+    );
+    await this.identifyIngestDeploymentServer(appDirNode, token);
+    actionState?.setMessage(
+      `Validating ingest with server ${this.ingestDeploymentServerClient.baseUrl ?? ''} for realm ${this.ingestDeploymentServerClient.environmentClassification}...`,
+    );
+    const validateResonse = await this._validate(
+      ingestDefinition,
+      undefined,
+      token,
+    );
+    if (
+      validateResonse.status !==
+      IngestDefinitionValidationResponseStatus.SUCCESS
+    ) {
+      throw new Error('Failed to validate Ingest Definition');
+    }
+    actionState?.setMessage(
+      `Validation Success. Deploying ingest with server ${this.ingestDeploymentServerClient.baseUrl ?? ''} for realm ${this.ingestDeploymentServerClient.environmentClassification}...`,
+    );
+    return this._deploy(ingestDefinition, undefined, token);
+  }
+
+  private async _validate(
+    ingestDefinition: string,
+    appDirNode: AppDirNode | undefined,
+    token: string | undefined,
+  ): Promise<IngestDefinitionValidationResponse> {
+    if (appDirNode) {
+      await this.identifyIngestDeploymentServer(appDirNode, token);
+    }
+    // validate
+    const response = await this.ingestDeploymentServerClient.validate(
+      ingestDefinition,
+      token,
+    );
+    return IngestDefinitionValidationResponse.serialization.fromJson(response);
+  }
+
+  private async _deploy(
+    ingestDefinition: string,
+    appDirNode: AppDirNode | undefined,
+    token: string | undefined,
+  ): Promise<IngestDefinitionDeploymentResponse> {
+    if (appDirNode) {
+      await this.identifyIngestDeploymentServer(appDirNode, token);
+    }
+    // validate
+    const response = (await this.ingestDeploymentServerClient.deploy(
+      ingestDefinition,
+      token,
+    )) as unknown as PlainObject<IngestDefinitionDeploymentResponse>;
+    return IngestDefinitionDeploymentResponse.serialization.fromJson(response);
+  }
+
+  private async identifyIngestDeploymentServer(
+    appDirNode: AppDirNode,
+    token: string | undefined,
+  ): Promise<void> {
+    // we do not change if current appDirNode is the same as the one we are trying to set
+    if (this.isCurrentAppDirNode(appDirNode)) {
+      return;
+    }
+    const serverConfig = IngestDeploymentServerConfig.serialization.fromJson(
+      await this.ingestDiscoveryServerClient.findProducerServer(
+        appDirNode.appDirId,
+        appDirNode.level,
+        token,
+      ),
+    );
+
+    this.ingestDeploymentServerClient.changeServer(serverConfig);
+    this.setCurrentAppDirNode(appDirNode);
+  }
+}

package/tsconfig.json

@@ -67,6 +67,7 @@
     "./src/__lib__/LegendStudioTesting.ts",
     "./src/__lib__/LegendStudioUserDataHelper.ts",
     "./src/__lib__/STO_Relational_LegendStudioCommand.ts",
+    "./src/application/LegendIngestionConfiguration.ts",
     "./src/application/LegendStudioApplicationConfig.ts",
     "./src/application/LegendStudioPluginManager.ts",
     "./src/components/__test-utils__/EmbeddedQueryBuilderTestUtils.ts",
@@ -108,6 +109,7 @@
     "./src/stores/editor/editor-state/diff-viewer-state/ProjectConfigurationDiffEditorState.ts",
     "./src/stores/editor/editor-state/element-editor-state/ClassEditorState.ts",
     "./src/stores/editor/editor-state/element-editor-state/ClassState.ts",
+    "./src/stores/editor/editor-state/element-editor-state/ElementEditorInitialConfiguration.ts",
     "./src/stores/editor/editor-state/element-editor-state/ElementEditorState.ts",
     "./src/stores/editor/editor-state/element-editor-state/ElementExternalFormatGenerationState.ts",
     "./src/stores/editor/editor-state/element-editor-state/ElementFileGenerationState.ts",
@@ -134,6 +136,7 @@
     "./src/stores/editor/editor-state/element-editor-state/function-activator/PostDeploymentActionEditorState.ts",
     "./src/stores/editor/editor-state/element-editor-state/function-activator/SnowflakeAppFunctionActivatorEditorState.ts",
     "./src/stores/editor/editor-state/element-editor-state/function-activator/testable/FunctionTestableState.ts",
+    "./src/stores/editor/editor-state/element-editor-state/ingest/IngestDefinitionEditorState.ts",
     "./src/stores/editor/editor-state/element-editor-state/mapping/FlatDataInstanceSetImplementationState.ts",
     "./src/stores/editor/editor-state/element-editor-state/mapping/MappingEditorState.ts",
     "./src/stores/editor/editor-state/element-editor-state/mapping/MappingElementDecorator.ts",
@@ -202,6 +205,10 @@
     "./src/stores/graph-modifier/STO_FlatData_GraphModifierHelper.ts",
     "./src/stores/graph-modifier/STO_Relational_GraphModifierHelper.ts",
     "./src/stores/graph-modifier/Testable_GraphModifierHelper.ts",
+    "./src/stores/ingestion/IngestDeploymentServerClient.ts",
+    "./src/stores/ingestion/IngestDiscoveryServerClient.ts",
+    "./src/stores/ingestion/IngestionDeploymentResponse.ts",
+    "./src/stores/ingestion/IngestionManager.ts",
     "./src/stores/lazy-text-editor/LazyTextEditorStore.ts",
     "./src/stores/project-reviewer/ProjectReviewerStore.ts",
     "./src/stores/project-view/ProjectViewerEditorMode.ts",
@@ -267,6 +274,7 @@
     "./src/components/editor/editor-group/function-activator/INTERNAL__UnknownFunctionActivatorEdtior.tsx",
     "./src/components/editor/editor-group/function-activator/SnowflakeAppFunctionActivatorEditor.tsx",
     "./src/components/editor/editor-group/function-activator/testable/FunctionTestableEditor.tsx",
+    "./src/components/editor/editor-group/ingest-editor/IngestDefinitionEditor.tsx",
     "./src/components/editor/editor-group/mapping-editor/ClassMappingEditor.tsx",
     "./src/components/editor/editor-group/mapping-editor/EnumerationMappingEditor.tsx",
     "./src/components/editor/editor-group/mapping-editor/FlatDataPropertyMappingEditor.tsx",