@finos/legend-query-builder 3.1.0 → 3.2.1

package/src/stores/data-access/DataAccessState.ts

@@ -0,0 +1,322 @@
+/**
+ * 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 { GenericLegendApplicationStore } from '@finos/legend-application';
+import {
+  DatasetEntitlementAccessGrantedReport,
+  type BasicGraphManagerState,
+  type DatasetEntitlementReport,
+  type DatasetSpecification,
+  DatasetEntitlementAccessApprovedReport,
+  DatasetEntitlementAccessRequestedReport,
+  DatasetEntitlementAccessNotGrantedReport,
+  DatasetEntitlementUnsupportedReport,
+} from '@finos/legend-graph';
+import {
+  ActionState,
+  assertErrorThrown,
+  uuid,
+  type GeneratorFn,
+  getNonNullableEntry,
+} from '@finos/legend-shared';
+import {
+  action,
+  computed,
+  flow,
+  flowResult,
+  makeObservable,
+  observable,
+} from 'mobx';
+import { QUERY_BUILDER_COLOR_THEME_KEY } from '../../__lib__/QueryBuilderColorTheme.js';
+
+export class DatasetAccessInfo {
+  readonly uuid = uuid();
+  readonly specification!: DatasetSpecification;
+
+  entitlementReport?: DatasetEntitlementReport | undefined;
+
+  constructor(specification: DatasetSpecification) {
+    makeObservable(this, {
+      entitlementReport: observable,
+      setEntitlementReport: action,
+    });
+
+    this.specification = specification;
+  }
+
+  setEntitlementReport(val: DatasetEntitlementReport | undefined): void {
+    this.entitlementReport = val;
+  }
+}
+
+type EntitlementCheckInfo = {
+  total: number;
+  data: { label: string; count: number; percentage: number; color: string }[];
+};
+
+export class DataAccessState {
+  readonly applicationStore: GenericLegendApplicationStore;
+  readonly graphManagerState: BasicGraphManagerState;
+
+  readonly surveyDatasets: () => Promise<DatasetSpecification[]>;
+  readonly checkDatasetEntitlements: (
+    datasets: DatasetSpecification[],
+  ) => Promise<DatasetEntitlementReport[]>;
+
+  readonly initialDatasets?: DatasetSpecification[] | undefined;
+  readonly surveyDatasetsState = ActionState.create();
+  readonly checkEntitlementsState = ActionState.create();
+
+  datasets: DatasetAccessInfo[] = [];
+
+  constructor(
+    applicationStore: GenericLegendApplicationStore,
+    graphManagerState: BasicGraphManagerState,
+    options: {
+      initialDatasets?: DatasetSpecification[] | undefined;
+      surveyDatasets: () => Promise<DatasetSpecification[]>;
+      checkDatasetEntitlements: (
+        datasets: DatasetSpecification[],
+      ) => Promise<DatasetEntitlementReport[]>;
+    },
+  ) {
+    makeObservable(this, {
+      datasets: observable,
+      entitlementCheckInfo: computed,
+      fetchDatasetSpecifications: flow,
+      fetchDatasetEntitlementReports: flow,
+    });
+
+    this.applicationStore = applicationStore;
+    this.graphManagerState = graphManagerState;
+    this.initialDatasets = options.initialDatasets;
+    this.datasets = (options.initialDatasets ?? []).map(
+      (dataset) => new DatasetAccessInfo(dataset),
+    );
+    this.surveyDatasets = options.surveyDatasets;
+    this.checkDatasetEntitlements = options.checkDatasetEntitlements;
+  }
+
+  get entitlementCheckInfo(): EntitlementCheckInfo {
+    const total = this.datasets.length;
+    if (!total) {
+      return {
+        total,
+        data: [
+          {
+            label: 'Access Granted',
+            count: 1,
+            percentage: 100,
+            color: this.applicationStore.layoutService.getColor(
+              QUERY_BUILDER_COLOR_THEME_KEY.DATA_ACCESS_OVERVIEW__CHART__ACCESS_GRANTED,
+            ),
+          },
+        ],
+      };
+    }
+
+    const info: EntitlementCheckInfo = {
+      total,
+      data: [],
+    };
+
+    const accessGrantedCount = this.datasets.filter(
+      (dataset) =>
+        dataset.entitlementReport instanceof
+        DatasetEntitlementAccessGrantedReport,
+    ).length;
+    const accessGrantedPercentage =
+      Math.round(accessGrantedCount / total) * 100;
+    info.data.push({
+      label: 'Access Granted',
+      count: accessGrantedCount,
+      percentage: accessGrantedPercentage,
+      color: this.applicationStore.layoutService.getColor(
+        QUERY_BUILDER_COLOR_THEME_KEY.DATA_ACCESS_OVERVIEW__CHART__ACCESS_GRANTED,
+      ),
+    });
+
+    const accessApprovedCount = this.datasets.filter(
+      (dataset) =>
+        dataset.entitlementReport instanceof
+        DatasetEntitlementAccessApprovedReport,
+    ).length;
+    const accessApprovedPercentage = Math.round(
+      (accessApprovedCount / total) * 100,
+    );
+    info.data.push({
+      label: 'Access Approved',
+      count: accessApprovedCount,
+      percentage: accessApprovedPercentage,
+      color: this.applicationStore.layoutService.getColor(
+        QUERY_BUILDER_COLOR_THEME_KEY.DATA_ACCESS_OVERVIEW__CHART__ACCESS_APPROVED,
+      ),
+    });
+
+    const accessRequestedCount = this.datasets.filter(
+      (dataset) =>
+        dataset.entitlementReport instanceof
+        DatasetEntitlementAccessRequestedReport,
+    ).length;
+    const accessRequestedPercentage = Math.round(
+      (accessRequestedCount / total) * 100,
+    );
+    info.data.push({
+      label: 'Access Requested',
+      count: accessRequestedCount,
+      percentage: accessRequestedPercentage,
+      color: this.applicationStore.layoutService.getColor(
+        QUERY_BUILDER_COLOR_THEME_KEY.DATA_ACCESS_OVERVIEW__CHART__ACCESS_REQUESTED,
+      ),
+    });
+
+    const accessNotGrantedCount = this.datasets.filter(
+      (dataset) =>
+        dataset.entitlementReport instanceof
+        DatasetEntitlementAccessNotGrantedReport,
+    ).length;
+    const accessNotGrantedPercentage =
+      Math.round(accessNotGrantedCount / total) * 100;
+    info.data.push({
+      label: 'Access Not Granted',
+      count: accessNotGrantedCount,
+      percentage: accessNotGrantedPercentage,
+      color: this.applicationStore.layoutService.getColor(
+        QUERY_BUILDER_COLOR_THEME_KEY.DATA_ACCESS_OVERVIEW__CHART__ACCESS_NOT_GRANTED,
+      ),
+    });
+
+    const unsupportedCount = this.datasets.filter(
+      (dataset) =>
+        dataset.entitlementReport instanceof
+        DatasetEntitlementUnsupportedReport,
+    ).length;
+    const unsupportedPercentage = Math.round((unsupportedCount / total) * 100);
+    info.data.push({
+      label: 'Unsupported',
+      count: unsupportedCount,
+      percentage: unsupportedPercentage,
+      color: this.applicationStore.layoutService.getColor(
+        QUERY_BUILDER_COLOR_THEME_KEY.DATA_ACCESS_OVERVIEW__CHART__UNSUPPORTED_ACCESS,
+      ),
+    });
+
+    const unknownCount =
+      total -
+      accessGrantedCount -
+      accessApprovedCount -
+      accessRequestedCount -
+      accessNotGrantedCount -
+      unsupportedCount;
+    const unknownPercentage = Math.round(unknownCount / total) * 100;
+    info.data.push({
+      label: 'Unknown',
+      count: unknownCount,
+      percentage: unknownPercentage,
+      color: this.applicationStore.layoutService.getColor(
+        QUERY_BUILDER_COLOR_THEME_KEY.DATA_ACCESS_OVERVIEW__CHART__UNSUPPORTED_ACCESS,
+      ),
+    });
+
+    let currentPercentageSum = 0;
+    for (let i = 0; i < info.data.length; ++i) {
+      const data = getNonNullableEntry(info.data, i);
+      if (currentPercentageSum + data.percentage >= 100) {
+        data.percentage = 100 - currentPercentageSum;
+        info.data = info.data.slice(0, i + 1);
+        break;
+      }
+      currentPercentageSum += data.percentage;
+    }
+
+    return info;
+  }
+
+  *fetchDatasetSpecifications(): GeneratorFn<void> {
+    this.surveyDatasetsState.inProgress();
+
+    try {
+      const datasets = (yield this.surveyDatasets()) as DatasetSpecification[];
+      this.datasets = datasets.map((dataset) => {
+        const existingDataset = this.datasets.find(
+          (ds) => ds.specification.hashCode === dataset.hashCode,
+        );
+        if (existingDataset) {
+          return existingDataset;
+        }
+        return new DatasetAccessInfo(dataset);
+      });
+    } catch (error) {
+      assertErrorThrown(error);
+      this.applicationStore.notificationService.notifyError(error);
+    } finally {
+      this.surveyDatasetsState.complete();
+    }
+  }
+
+  *fetchDatasetEntitlementReports(): GeneratorFn<void> {
+    this.checkEntitlementsState.inProgress();
+
+    try {
+      const reports = (yield this.checkDatasetEntitlements(
+        this.datasets.map((dataset) => dataset.specification),
+      )) as DatasetEntitlementReport[];
+      this.datasets.forEach((dataset) => {
+        const matchingReport = reports.find(
+          (report) =>
+            report.dataset.hashCode === dataset.specification.hashCode,
+        );
+        if (matchingReport) {
+          dataset.setEntitlementReport(matchingReport);
+          return;
+        }
+        dataset.setEntitlementReport(undefined);
+      });
+      const newDatasets: DatasetAccessInfo[] = [];
+      reports.forEach((report) => {
+        const matchingDataset = this.datasets.find(
+          (dataset) =>
+            dataset.specification.hashCode === report.dataset.hashCode,
+        );
+        if (!matchingDataset) {
+          const newDataset = new DatasetAccessInfo(report.dataset);
+          newDataset.setEntitlementReport(report);
+          newDatasets.push(newDataset);
+        }
+      });
+      this.datasets = this.datasets.concat(newDatasets);
+    } catch (error) {
+      assertErrorThrown(error);
+      this.applicationStore.notificationService.notifyError(error);
+    } finally {
+      this.checkEntitlementsState.complete();
+    }
+  }
+
+  async intialize(): Promise<void> {
+    if (!this.initialDatasets) {
+      await flowResult(this.fetchDatasetSpecifications());
+      await flowResult(this.fetchDatasetEntitlementReports());
+    } else {
+      await flowResult(this.fetchDatasetEntitlementReports());
+    }
+  }
+
+  async refresh(): Promise<void> {
+    await flowResult(this.fetchDatasetSpecifications());
+    await flowResult(this.fetchDatasetEntitlementReports());
+  }
+}

package/src/stores/entitlements/QueryBuilderCheckEntitlementsState.ts

@@ -18,29 +18,76 @@ import { type Hashable, hashArray } from '@finos/legend-shared';
 import { makeObservable, observable, action, computed } from 'mobx';
 import { QUERY_BUILDER_STATE_HASH_STRUCTURE } from '../QueryBuilderStateHashUtils.js';
 import type { QueryBuilderState } from '../QueryBuilderState.js';
+import { DataAccessState } from '../data-access/DataAccessState.js';
+import {
+  RuntimePointer,
+  type DatasetEntitlementReport,
+  type DatasetSpecification,
+  InMemoryGraphData,
+} from '@finos/legend-graph';
 
 export class QueryBuilderCheckEntitlementsState implements Hashable {
   readonly queryBuilderState: QueryBuilderState;
-  isCheckingEntitlements = false;
+
+  dataAccessState?: DataAccessState | undefined;
+  showCheckEntitlementsViewer = false;
 
   constructor(queryBuilderState: QueryBuilderState) {
     makeObservable(this, {
-      isCheckingEntitlements: observable,
-      setIsCheckingEntitlements: action,
+      showCheckEntitlementsViewer: observable,
+      dataAccessState: observable,
+      setShowCheckEntitlementsViewer: action,
       hashCode: computed,
     });
 
     this.queryBuilderState = queryBuilderState;
   }
 
-  setIsCheckingEntitlements(val: boolean): void {
-    this.isCheckingEntitlements = val;
+  setShowCheckEntitlementsViewer(val: boolean): void {
+    this.showCheckEntitlementsViewer = val;
+
+    this.dataAccessState = undefined;
+    if (
+      this.queryBuilderState.mapping &&
+      this.queryBuilderState.runtimeValue instanceof RuntimePointer
+    ) {
+      const mappingPath = this.queryBuilderState.mapping.path;
+      const runtimePath =
+        this.queryBuilderState.runtimeValue.packageableRuntime.value.path;
+      this.dataAccessState = new DataAccessState(
+        this.queryBuilderState.applicationStore,
+        this.queryBuilderState.graphManagerState,
+        {
+          surveyDatasets: async (): Promise<DatasetSpecification[]> =>
+            this.queryBuilderState.graphManagerState.graphManager.surveyDatasets(
+              mappingPath,
+              runtimePath,
+              this.queryBuilderState.buildQuery(),
+              new InMemoryGraphData(
+                this.queryBuilderState.graphManagerState.graph,
+              ),
+            ),
+          checkDatasetEntitlements: async (
+            datasets: DatasetSpecification[],
+          ): Promise<DatasetEntitlementReport[]> =>
+            this.queryBuilderState.graphManagerState.graphManager.checkDatasetEntitlements(
+              datasets,
+              mappingPath,
+              runtimePath,
+              this.queryBuilderState.buildQuery(),
+              new InMemoryGraphData(
+                this.queryBuilderState.graphManagerState.graph,
+              ),
+            ),
+        },
+      );
+    }
   }
 
   get hashCode(): string {
     return hashArray([
       QUERY_BUILDER_STATE_HASH_STRUCTURE.CHECK_ENTITLEMENTS_STATE,
-      this.isCheckingEntitlements,
+      this.showCheckEntitlementsViewer,
     ]);
   }
 }

package/src/stores/shared/ValueSpecificationEditorHelper.ts

@@ -16,10 +16,13 @@
 
 import {
   type PureModel,
-  VariableExpression,
+  type GraphManagerState,
   type ValueSpecification,
   type Type,
   type Enum,
+  type ObserverContext,
+  type RawLambda,
+  VariableExpression,
   CollectionInstanceValue,
   Enumeration,
   EnumValueExplicitReference,
@@ -32,7 +35,12 @@ import {
   PRIMITIVE_TYPE,
   INTERNAL__PropagatedValue,
   SimpleFunctionExpression,
-  type ObserverContext,
+  LambdaFunction,
+  FunctionType,
+  PackageableElementExplicitReference,
+  Multiplicity,
+  CORE_PURE_PATH,
+  buildRawLambdaFromLambdaFunction,
 } from '@finos/legend-graph';
 import { Randomizer, UnsupportedOperationError } from '@finos/legend-shared';
 import { generateDefaultValueForPrimitiveType } from '../QueryBuilderValueSpecificationHelper.js';
@@ -177,6 +185,35 @@ export const buildDefaultInstanceValue = (
   }
 };
 
+export const buildDefaultEmptyStringLambda = (
+  graph: PureModel,
+  observerContext: ObserverContext,
+): LambdaFunction => {
+  const lambdaFunction = new LambdaFunction(
+    new FunctionType(
+      PackageableElementExplicitReference.create(
+        graph.getType(CORE_PURE_PATH.ANY),
+      ),
+      Multiplicity.ONE,
+    ),
+  );
+  lambdaFunction.expressionSequence[0] = buildDefaultInstanceValue(
+    graph,
+    PrimitiveType.STRING,
+    observerContext,
+  );
+  return lambdaFunction;
+};
+
+export const buildDefaultEmptyStringRawLambda = (
+  graphState: GraphManagerState,
+  observerContext: ObserverContext,
+): RawLambda =>
+  buildRawLambdaFromLambdaFunction(
+    buildDefaultEmptyStringLambda(graphState.graph, observerContext),
+    graphState,
+  );
+
 export const generateVariableExpressionMockValue = (
   parameter: VariableExpression,
   graph: PureModel,

package/tsconfig.json

@@ -34,6 +34,7 @@
   "files": [
     "./src/__test__.ts",
     "./src/index.ts",
+    "./src/__lib__/QueryBuilderColorTheme.ts",
     "./src/__lib__/QueryBuilderDocumentation.ts",
     "./src/__lib__/QueryBuilderEvent.ts",
     "./src/__lib__/QueryBuilderSetting.ts",
@@ -71,8 +72,11 @@
     "./src/stores/QueryBuilderValueSpecificationBuilder.ts",
     "./src/stores/QueryBuilderValueSpecificationBuilderHelper.ts",
     "./src/stores/QueryBuilderValueSpecificationHelper.ts",
+    "./src/stores/QueryBuilder_LegendApplicationPlugin_Extension.ts",
+    "./src/stores/QueryLoaderState.ts",
     "./src/stores/ServiceInfo.ts",
     "./src/stores/__test-utils__/QueryBuilderStateTestUtils.ts",
+    "./src/stores/data-access/DataAccessState.ts",
     "./src/stores/entitlements/QueryBuilderCheckEntitlementsState.ts",
     "./src/stores/execution-plan/ExecutionPlanState.ts",
     "./src/stores/explorer/QueryBuilderExplorerState.ts",
@@ -213,8 +217,10 @@
     "./src/components/QueryBuilderSideBar.tsx",
     "./src/components/QueryBuilderTextEditor.tsx",
     "./src/components/QueryBuilderUnsupportedQueryEditor.tsx",
+    "./src/components/QueryLoader.tsx",
     "./src/components/ServiceQuerySetupUtils.tsx",
     "./src/components/__test-utils__/QueryBuilderComponentTestUtils.tsx",
+    "./src/components/data-access/DataAccessOverview.tsx",
     "./src/components/execution-plan/ExecutionPlanViewer.tsx",
     "./src/components/execution-plan/SQLExecutionNodeViewer.tsx",
     "./src/components/explorer/QueryBuilderExplorerPanel.tsx",