@finos/legend-application-data-cube 0.7.34 → 0.7.36

package/src/stores/builder/source/LakehouseConsumerDataCubeSourceBuilderState.ts

@@ -30,31 +30,25 @@ import {
   ActionState,
   assertErrorThrown,
   guaranteeNonNullable,
-  isNonNullable,
-  uniq,
   type GeneratorFn,
   type PlainObject,
 } from '@finos/legend-shared';
 import type { DataCubeAlertService } from '@finos/legend-data-cube';
 import type { LegendDataCubeApplicationStore } from '../../LegendDataCubeBaseStore.js';
 import type { LegendDataCubeDataCubeEngine } from '../../LegendDataCubeDataCubeEngine.js';
+import { type LakehouseContractServerClient } from '@finos/legend-server-lakehouse';
 import {
-  type LakehousePlatformServerClient,
-  type LakehouseContractServerClient,
-  type IngestDeploymentServerConfig,
-  filterEnvironmentsByEntitlementsEnv,
-  getIngestDeploymentServerConfigName,
-} from '@finos/legend-server-lakehouse';
-import { VersionedProjectData } from '@finos/legend-server-depot';
+  resolveVersion,
+  VersionedProjectData,
+  type DepotServerClient,
+} from '@finos/legend-server-depot';
 import {
   V1_SdlcDeploymentDataProductOrigin,
   type V1_EntitlementsDataProductLite,
   type V1_EntitlementsDataProductLiteResponse,
-  V1_entitlementsDataProductDetailsResponseToDataProductDetails,
+  V1_EntitlementsLakehouseEnvironmentType,
   V1_DataProductOriginType,
   V1_AdHocDeploymentDataProductOrigin,
-  type V1_EntitlementsDataProductDetails,
-  V1_isIngestEnvsCompatibleWithEntitlements,
   V1_LegendSDLC,
   V1_serializePureModelContext,
   V1_PureModelContextPointer,
@@ -64,7 +58,10 @@ import {
   V1_Protocol,
   V1_PureGraphManager,
   PureClientVersion,
-  type V1_EntitlementsUserEnvResponse,
+  V1_DataProduct,
+  V1_dataProductModelSchema,
+  V1_deserializePureModelContextData,
+  V1_EntitlementsDataProductLiteModelSchema,
 } from '@finos/legend-graph';
 import {
   RawLakehouseAdhocOrigin,
@@ -72,68 +69,61 @@ import {
   RawLakehouseSdlcOrigin,
 } from '../../model/LakehouseConsumerDataCubeSource.js';
 import { LegendDataCubeCodeEditorState } from '../LegendDataCubeCodeEditorState.js';
+import type { Entity } from '@finos/legend-storage';
+import { deserialize } from 'serializr';
 
 export class LakehouseConsumerDataCubeSourceBuilderState extends LegendDataCubeSourceBuilderState {
   warehouse: string | undefined;
-  selectedDataProduct: string | undefined;
-  selectedAccessPoint: string | undefined;
+  selectedDataProduct: V1_EntitlementsDataProductLite | undefined;
+  // accesspoint is an array of id and title
+  selectedAccessPoint: [string, string] | undefined;
   paths: string[] = [];
   dataProducts: V1_EntitlementsDataProductLite[] = [];
-  accessPoints: string[] = [];
+  accessPoints: Map<string, string | undefined> = new Map();
   dpCoordinates: VersionedProjectData | undefined;
   origin: string | undefined;
   fullGraphGrammar: string | undefined;
   deploymentId: number | undefined;
-  userEntitlementEnvs: string[] = [];
-  dataProductDetails: V1_EntitlementsDataProductDetails[] | undefined;
+  envMode: V1_EntitlementsLakehouseEnvironmentType;
   showQueryEditor = false;
   DEFAULT_CONSUMER_WAREHOUSE = 'LAKEHOUSE_CONSUMER_DEFAULT_WH';
   codeEditorState: LegendDataCubeCodeEditorState;
 
-  // envs
-  allEnvironments: IngestDeploymentServerConfig[] | undefined;
-  selectedEnvironment: IngestDeploymentServerConfig | undefined;
-
-  private readonly _platformServerClient: LakehousePlatformServerClient;
   private readonly _contractServerClient: LakehouseContractServerClient;
+  private readonly _depotServerClient: DepotServerClient;
   readonly dataProductLoadingState = ActionState.create();
   readonly ingestEnvLoadingState = ActionState.create();
 
   constructor(
     application: LegendDataCubeApplicationStore,
     engine: LegendDataCubeDataCubeEngine,
-    platformServerClient: LakehousePlatformServerClient,
+    depotServerClient: DepotServerClient,
     contractServerClient: LakehouseContractServerClient,
     alertService: DataCubeAlertService,
   ) {
     super(application, engine, alertService);
-    this._platformServerClient = platformServerClient;
     this._contractServerClient = contractServerClient;
+    this._depotServerClient = depotServerClient;
 
     makeObservable(this, {
       warehouse: observable,
       dataProducts: observable,
       selectedDataProduct: observable,
+      envMode: observable,
       accessPoints: observable,
-      allEnvironments: observable,
-      dataProductDetails: observable,
-      environments: computed,
-      selectedDataProductDetail: computed,
+      filteredDataProducts: computed,
       selectedAccessPoint: observable,
-      selectedEnvironment: observable,
       showQueryEditor: observable,
       setShowQueryEditor: action,
+      setEnvMode: action,
       loadDataProducts: flow,
-      fetchEnvironment: flow,
-      fetchUserEntitlementEnvs: flow,
 
       setWarehouse: action,
       setDataProducts: action,
       setSelectedDataProduct: action,
       setAccessPoints: action,
       setSelectedAccessPoint: action,
-      setSelectedEnvironment: action,
-      setUserEntitlementEnv: action,
+      resetDataProduct: action,
     });
 
     this.codeEditorState = new LegendDataCubeCodeEditorState(
@@ -142,6 +132,8 @@ export class LakehouseConsumerDataCubeSourceBuilderState extends LegendDataCubeS
       undefined,
     );
 
+    this.envMode = V1_EntitlementsLakehouseEnvironmentType.PRODUCTION;
+
     reaction(
       () => this.selectedAccessPoint,
       (accessPoint) => {
@@ -158,84 +150,40 @@ export class LakehouseConsumerDataCubeSourceBuilderState extends LegendDataCubeS
     this.dataProducts = dataProducts;
   }
 
-  setSelectedDataProduct(dataProduct: string | undefined) {
-    this.selectedDataProduct = dataProduct;
+  setSelectedDataProduct(
+    dataProduct: V1_EntitlementsDataProductLite | undefined,
+  ) {
+    this.selectedDataProduct = deserialize(
+      V1_EntitlementsDataProductLiteModelSchema,
+      dataProduct,
+    );
   }
 
-  setAccessPoints(accessPoints: string[]) {
+  setAccessPoints(accessPoints: Map<string, string | undefined>) {
     this.accessPoints = accessPoints;
   }
 
-  setAllEnvironments(environments: IngestDeploymentServerConfig[]) {
-    this.allEnvironments = environments;
-  }
-
-  setSelectedAccessPoint(accessPoint: string | undefined) {
+  setSelectedAccessPoint(accessPoint: [string, string] | undefined) {
     this.selectedAccessPoint = accessPoint;
   }
 
-  setSelectedEnvironment(
-    environment: IngestDeploymentServerConfig | undefined,
-  ) {
-    this.selectedEnvironment = environment;
+  setEnvMode(env: V1_EntitlementsLakehouseEnvironmentType): void {
+    this.envMode = env;
   }
 
-  setUserEntitlementEnv(envs: string[]) {
-    this.userEntitlementEnvs = envs;
+  get filteredDataProducts(): V1_EntitlementsDataProductLite[] {
+    if (!this.dataProducts.length) {
+      return [];
+    }
+    return this.dataProducts.filter(
+      (dp) => dp.lakehouseEnvironment?.type === this.envMode,
+    );
   }
 
   setShowQueryEditor(val: boolean): void {
     this.showQueryEditor = val;
   }
 
-  get environments(): IngestDeploymentServerConfig[] {
-    const allEnvironments = this.allEnvironments;
-    if (allEnvironments) {
-      const details = this.dataProductDetails?.map(
-        (detail) => detail.lakehouseEnvironment?.type,
-      );
-      if (details?.length && !details.includes(undefined)) {
-        const entitlementsTypes = uniq(details.filter(isNonNullable));
-        return uniq(
-          entitlementsTypes
-            .map((type) =>
-              filterEnvironmentsByEntitlementsEnv(type, allEnvironments),
-            )
-            .flat()
-            .filter((env) =>
-              this.userEntitlementEnvs.some((userEnv) =>
-                userEnv.includes(env.environmentName),
-              ),
-            ),
-        );
-      }
-      return allEnvironments;
-    }
-    return [];
-  }
-
-  get selectedDataProductDetail():
-    | V1_EntitlementsDataProductDetails
-    | undefined {
-    const selectedEnv = this.selectedEnvironment;
-    if (selectedEnv && this.dataProductDetails?.length) {
-      const details = this.dataProductDetails.filter((dpDetail) => {
-        const dpDetailType = dpDetail.lakehouseEnvironment?.type;
-        if (!dpDetailType) {
-          return false;
-        }
-        return V1_isIngestEnvsCompatibleWithEntitlements(
-          selectedEnv.environmentClassification,
-          dpDetailType,
-        );
-      });
-      if (details.length === 1) {
-        return guaranteeNonNullable(details[0]);
-      }
-    }
-    return undefined;
-  }
-
   *loadDataProducts(access_token?: string): GeneratorFn<void> {
     try {
       this.dataProductLoadingState.inProgress();
@@ -252,31 +200,16 @@ export class LakehouseConsumerDataCubeSourceBuilderState extends LegendDataCubeS
     }
   }
 
-  async fetchDataProduct(access_token?: string) {
-    this.resetEnvironment();
-
-    const selectedDp = guaranteeNonNullable(this.selectedDataProduct);
-    this.dataProductDetails =
-      V1_entitlementsDataProductDetailsResponseToDataProductDetails(
-        await this._contractServerClient.getDataProduct(
-          selectedDp.split('::').pop() ?? '',
-          access_token,
-        ),
-      );
-  }
-
   async fetchAccessPoints() {
     try {
-      this.resetAccessPoint();
-      const dataProduct = guaranteeNonNullable(
-        this.selectedDataProductDetail,
-        'unable to resolve data product',
-      );
-      if (dataProduct.origin instanceof V1_SdlcDeploymentDataProductOrigin) {
+      this.resetEnvironment();
+      const selectedDp = guaranteeNonNullable(this.selectedDataProduct);
+      let v1DataProduct: V1_DataProduct | undefined;
+      if (selectedDp.origin instanceof V1_SdlcDeploymentDataProductOrigin) {
         const versionedData = new VersionedProjectData();
-        versionedData.groupId = dataProduct.origin.group;
-        versionedData.artifactId = dataProduct.origin.artifact;
-        versionedData.versionId = dataProduct.origin.version;
+        versionedData.groupId = selectedDp.origin.group;
+        versionedData.artifactId = selectedDp.origin.artifact;
+        versionedData.versionId = selectedDp.origin.version;
         this.dpCoordinates = versionedData;
         this.origin = V1_DataProductOriginType.SDLC_DEPLOYMENT;
 
@@ -297,25 +230,50 @@ export class LakehouseConsumerDataCubeSourceBuilderState extends LegendDataCubeS
         );
 
         this.codeEditorState.setModel(model);
+
+        v1DataProduct = deserialize(
+          V1_dataProductModelSchema(
+            this._application.pluginManager.getPureProtocolProcessorPlugins(),
+          ),
+          (
+            (await this._depotServerClient.getVersionEntity(
+              selectedDp.origin.group,
+              selectedDp.origin.artifact,
+              resolveVersion(selectedDp.origin.version),
+              guaranteeNonNullable(selectedDp.fullPath),
+            )) as unknown as Entity
+          ).content,
+        );
       } else if (
-        dataProduct.origin instanceof V1_AdHocDeploymentDataProductOrigin
+        selectedDp.origin instanceof V1_AdHocDeploymentDataProductOrigin
       ) {
         this.dpCoordinates = undefined;
         this.origin = V1_DataProductOriginType.AD_HOC_DEPLOYMENT;
-        this.fullGraphGrammar = dataProduct.origin.definition;
+        this.fullGraphGrammar = selectedDp.origin.definition;
 
         const model = await this._engine.parseCompatibleModel(
           this.fullGraphGrammar,
         );
 
         this.codeEditorState.setModel(model);
+
+        v1DataProduct = guaranteeNonNullable(
+          V1_deserializePureModelContextData(model)
+            .elements.filter((ele) => ele instanceof V1_DataProduct)
+            .map((ele) => ele)
+            .at(0),
+        );
       }
-      this.deploymentId = dataProduct.deploymentId;
-      this.setAccessPoints(
-        dataProduct.dataProduct.accessPoints.map(
-          (accessPoint) => accessPoint.name,
-        ),
-      );
+      this.deploymentId = selectedDp.deploymentId;
+
+      const accessPointMap = new Map<string, string | undefined>();
+      guaranteeNonNullable(v1DataProduct).accessPointGroups.forEach((apg) => {
+        apg.accessPoints.forEach((accessPoint) => {
+          accessPointMap.set(accessPoint.id, accessPoint.title);
+        });
+      });
+
+      this.setAccessPoints(accessPointMap);
     } catch (error) {
       assertErrorThrown(error);
       this._application.notificationService.notifyError(
@@ -324,36 +282,13 @@ export class LakehouseConsumerDataCubeSourceBuilderState extends LegendDataCubeS
     }
   }
 
-  *fetchEnvironment(access_token: string | undefined): GeneratorFn<void> {
-    this.ingestEnvLoadingState.inProgress();
-    const ingestServerConfigs =
-      (yield this._platformServerClient.getIngestEnvironmentSummaries(
-        access_token,
-      )) as IngestDeploymentServerConfig[];
-    this.setAllEnvironments(ingestServerConfigs);
-    this.ingestEnvLoadingState.complete();
-  }
-
-  *fetchUserEntitlementEnvs(
-    access_token: string | undefined,
-  ): GeneratorFn<void> {
-    const entitledEnvs =
-      (yield this._contractServerClient.getUserEntitlementEnvs(
-        this._application.identityService.currentUser,
-        access_token,
-      )) as V1_EntitlementsUserEnvResponse;
-    this.setUserEntitlementEnv(
-      entitledEnvs.users.map((env) => env.lakehouseEnvironment),
-    );
-  }
-
   async initializeQuery() {
     const query = new V1_ClassInstance();
     query.type = V1_ClassInstanceType.DATA_PRODUCT_ACCESSOR;
     const dataProductAccessor = new V1_DataProductAccessor();
     dataProductAccessor.path = [
-      guaranteeNonNullable(this.selectedDataProduct),
-      guaranteeNonNullable(this.selectedAccessPoint),
+      guaranteeNonNullable(this.selectedDataProduct?.fullPath),
+      guaranteeNonNullable(this.selectedAccessPoint)[0],
     ];
     dataProductAccessor.parameters = [];
     query.value = dataProductAccessor;
@@ -363,26 +298,18 @@ export class LakehouseConsumerDataCubeSourceBuilderState extends LegendDataCubeS
   }
 
   reset() {
-    this.setWarehouse(undefined);
     this.setDataProducts([]);
-    this.setSelectedDataProduct(undefined);
-    this.setAccessPoints([]);
-    this.setSelectedAccessPoint(undefined);
-    this.setSelectedEnvironment(undefined);
-    this.dpCoordinates = undefined;
+    this.resetDataProduct();
   }
 
-  resetEnvironment() {
-    this.setWarehouse(undefined);
-    this.setAccessPoints([]);
-    this.setSelectedAccessPoint(undefined);
-    this.setSelectedEnvironment(undefined);
-    this.dpCoordinates = undefined;
+  resetDataProduct() {
+    this.setSelectedDataProduct(undefined);
+    this.resetEnvironment();
   }
 
-  resetAccessPoint() {
+  resetEnvironment() {
     this.setWarehouse(undefined);
-    this.setAccessPoints([]);
+    this.setAccessPoints(new Map());
     this.setSelectedAccessPoint(undefined);
     this.dpCoordinates = undefined;
   }
@@ -396,7 +323,7 @@ export class LakehouseConsumerDataCubeSourceBuilderState extends LegendDataCubeS
       Boolean(this.warehouse) &&
       Boolean(this.selectedAccessPoint) &&
       Boolean(this.selectedDataProduct) &&
-      Boolean(this.selectedEnvironment) &&
+      Boolean(this.envMode) &&
       !this.codeEditorState.hasErrors
     );
   }
@@ -406,17 +333,12 @@ export class LakehouseConsumerDataCubeSourceBuilderState extends LegendDataCubeS
     this.paths = [];
     this.paths.push(
       ...[
-        guaranteeNonNullable(this.selectedDataProduct),
-        guaranteeNonNullable(this.selectedAccessPoint),
+        guaranteeNonNullable(this.selectedDataProduct?.fullPath),
+        guaranteeNonNullable(this.selectedAccessPoint)[0],
       ],
     );
 
     const rawSource = new RawLakehouseConsumerDataCubeSource();
-    const selectedEnv = guaranteeNonNullable(this.selectedEnvironment);
-    rawSource.environment = guaranteeNonNullable(
-      getIngestDeploymentServerConfigName(selectedEnv),
-      'Unable to resolve env env string',
-    );
     if (this.origin === V1_DataProductOriginType.SDLC_DEPLOYMENT) {
       const lakehouseOrigin = new RawLakehouseSdlcOrigin();
       lakehouseOrigin.dpCoordinates = guaranteeNonNullable(this.dpCoordinates);
@@ -425,6 +347,7 @@ export class LakehouseConsumerDataCubeSourceBuilderState extends LegendDataCubeS
       rawSource.origin = new RawLakehouseAdhocOrigin();
     }
     rawSource.paths = this.paths;
+    rawSource.environment = guaranteeNonNullable(this.envMode);
     rawSource.warehouse = guaranteeNonNullable(this.warehouse);
     rawSource.deploymentId = this.deploymentId;
     rawSource.query = this.codeEditorState.code;

package/src/stores/model/LakehouseConsumerDataCubeSource.ts

@@ -44,7 +44,7 @@ export class LakehouseConsumerDataCubeSource extends DataCubeSource {
   dpCoordinates?: VersionedProjectData;
   runtime!: string;
   warehouse!: string;
-  environment!: string;
+  userEnvironment!: string;
   paths!: string[];
   deploymentId?: number | undefined;
 }