@finos/legend-query-builder 3.2.0 → 3.2.2

package/src/components/shared/LambdaEditor.tsx

@@ -23,7 +23,6 @@ import {
   LongArrowAltDownIcon,
   LongArrowAltUpIcon,
   Dialog,
-  useResizeDetector,
   Modal,
   ModalBody,
   ModalFooter,
@@ -154,13 +153,6 @@ const LambdaEditorInline = observer(
       }
     };
 
-    const { ref, width, height } = useResizeDetector<HTMLDivElement>();
-    useEffect(() => {
-      if (width !== undefined && height !== undefined) {
-        editor?.layout({ width, height });
-      }
-    }, [editor, width, height]);
-
     useEffect(() => {
       if (!editor && textInputRef.current) {
         const element = textInputRef.current;
@@ -187,8 +179,8 @@ const LambdaEditorInline = observer(
           language: CODE_EDITOR_LANGUAGE.PURE,
           theme: applicationStore.layoutService
             .TEMPORARY__isLightColorThemeEnabled
-            ? CODE_EDITOR_THEME.TEMPORARY__VSCODE_LIGHT
-            : CODE_EDITOR_THEME.LEGEND,
+            ? CODE_EDITOR_THEME.BUILT_IN__VSCODE_LIGHT
+            : CODE_EDITOR_THEME.DEFAULT_DARK,
           ...lambdaEditorOptions,
         });
         setEditor(_editor);
@@ -341,7 +333,6 @@ const LambdaEditorInline = observer(
           })}
         >
           <div
-            ref={ref}
             data-testid={QUERY_BUILDER_TEST_ID.LAMBDA_EDITOR__EDITOR_INPUT}
             className="lambda-editor__editor__input"
           >
@@ -451,13 +442,6 @@ const LambdaEditorPopUp = observer(
       transformLambdaToString(true),
     );
 
-    const { ref, width, height } = useResizeDetector<HTMLDivElement>();
-    useEffect(() => {
-      if (width !== undefined && height !== undefined) {
-        editor?.layout({ width, height });
-      }
-    }, [editor, width, height]);
-
     const onEnter = (): void => {
       if (!editor && textInputRef.current) {
         const element = textInputRef.current;
@@ -466,8 +450,8 @@ const LambdaEditorPopUp = observer(
           language: CODE_EDITOR_LANGUAGE.PURE,
           theme: applicationStore.layoutService
             .TEMPORARY__isLightColorThemeEnabled
-            ? CODE_EDITOR_THEME.TEMPORARY__VSCODE_LIGHT
-            : CODE_EDITOR_THEME.LEGEND,
+            ? CODE_EDITOR_THEME.BUILT_IN__VSCODE_LIGHT
+            : CODE_EDITOR_THEME.DEFAULT_DARK,
         });
         setEditor(_editor);
       }
@@ -613,7 +597,6 @@ const LambdaEditorPopUp = observer(
           <ModalBody>
             <div className={clsx('lambda-editor__popup__content', className)}>
               <div
-                ref={ref}
                 data-testid={QUERY_BUILDER_TEST_ID.LAMBDA_EDITOR__EDITOR_INPUT}
                 className="lambda-editor__editor__input"
               >

package/src/index.ts

@@ -70,6 +70,10 @@ export * from './stores/shared/ValueSpecificationEditorHelper.js';
 
 export * from './components/execution-plan/ExecutionPlanViewer.js';
 export * from './stores/execution-plan/ExecutionPlanState.js';
+
 export * from './components/QueryLoader.js';
 export * from './stores/QueryLoaderState.js';
 export * from './stores/QueryBuilder_LegendApplicationPlugin_Extension.js';
+
+export * from './stores/data-access/DataAccessState.js';
+export * from './components/data-access/DataAccessOverview.js';

package/src/stores/QueryBuilderState.ts

@@ -31,6 +31,7 @@ import {
   filterByType,
   ActionState,
   hashArray,
+  assertTrue,
 } from '@finos/legend-shared';
 import { QueryBuilderFilterState } from './filter/QueryBuilderFilterState.js';
 import { QueryBuilderFetchStructureState } from './fetch-structure/QueryBuilderFetchStructureState.js';
@@ -62,6 +63,15 @@ import {
   buildLambdaVariableExpressions,
   buildRawLambdaFromLambdaFunction,
   type ValueSpecification,
+  PrimitiveType,
+  type Type,
+  SimpleFunctionExpression,
+  extractElementNameFromPath,
+  SUPPORTED_FUNCTIONS,
+  PackageableElementExplicitReference,
+  InstanceValue,
+  Multiplicity,
+  RuntimePointer,
 } from '@finos/legend-graph';
 import { buildLambdaFunction } from './QueryBuilderValueSpecificationBuilder.js';
 import type {
@@ -79,6 +89,8 @@ import { QUERY_BUILDER_COMMAND_KEY } from './QueryBuilderCommand.js';
 import { QueryBuilderWatermarkState } from './watermark/QueryBuilderWatermarkState.js';
 import { QueryBuilderConstantsState } from './QueryBuilderConstantsState.js';
 import { QueryBuilderCheckEntitlementsState } from './entitlements/QueryBuilderCheckEntitlementsState.js';
+import { QueryBuilderTDSState } from './fetch-structure/tds/QueryBuilderTDSState.js';
+import { QUERY_BUILDER_PURE_PATH } from '../graph/QueryBuilderMetaModelConst.js';
 
 export abstract class QueryBuilderState implements CommandRegistrar {
   readonly applicationStore: GenericLegendApplicationStore;
@@ -87,7 +99,6 @@ export abstract class QueryBuilderState implements CommandRegistrar {
   readonly changeDetectionState: QueryBuilderChangeDetectionState;
   readonly queryCompileState = ActionState.create();
   readonly observerContext: ObserverContext;
-  readonly saveQueryProgressState = ActionState.create();
 
   explorerState: QueryBuilderExplorerState;
   functionsExplorerState: QueryFunctionsExplorerState;
@@ -162,7 +173,6 @@ export abstract class QueryBuilderState implements CommandRegistrar {
       changeMapping: action,
 
       rebuildWithQuery: action,
-      saveQuery: action,
       compileQuery: flow,
       hashCode: computed,
     });
@@ -381,6 +391,59 @@ export abstract class QueryBuilderState implements CommandRegistrar {
     );
   }
 
+  buildFromQuery(): RawLambda {
+    assertTrue(
+      this.isQuerySupported,
+      'Query must be supported to build from function',
+    );
+    const mapping = guaranteeNonNullable(
+      this.mapping,
+      'Mapping required to build from() function',
+    );
+    const runtime = guaranteeNonNullable(
+      this.runtimeValue,
+      'Runtime required to build from query',
+    );
+    const runtimePointer = guaranteeType(
+      runtime,
+      RuntimePointer,
+    ).packageableRuntime;
+    const lambdaFunc = buildLambdaFunction(this);
+    const currentExpression = guaranteeNonNullable(
+      lambdaFunc.expressionSequence[0],
+    );
+    const _func = new SimpleFunctionExpression(
+      extractElementNameFromPath(SUPPORTED_FUNCTIONS.FROM),
+    );
+
+    const mappingInstance = new InstanceValue(Multiplicity.ONE, undefined);
+    mappingInstance.values = [
+      PackageableElementExplicitReference.create(mapping),
+    ];
+    const runtimeInstance = new InstanceValue(Multiplicity.ONE, undefined);
+    runtimeInstance.values = [
+      PackageableElementExplicitReference.create(runtimePointer.value),
+    ];
+    _func.parametersValues = [
+      currentExpression,
+      mappingInstance,
+      runtimeInstance,
+    ];
+    lambdaFunc.expressionSequence = [_func];
+    return buildRawLambdaFromLambdaFunction(lambdaFunc, this.graphManagerState);
+  }
+
+  getQueryReturnType(): Type {
+    if (
+      this.fetchStructureState.implementation instanceof QueryBuilderTDSState
+    ) {
+      return this.graphManagerState.graph.getClass(
+        QUERY_BUILDER_PURE_PATH.TDS_TABULAR_DATASET,
+      );
+    }
+    return PrimitiveType.STRING;
+  }
+
   initializeWithQuery(query: RawLambda): void {
     this.rebuildWithQuery(query);
     this.resetQueryResult();
@@ -452,23 +515,6 @@ export abstract class QueryBuilderState implements CommandRegistrar {
     }
   }
 
-  async saveQuery(
-    onSaveQuery: (lambda: RawLambda) => Promise<void>,
-  ): Promise<void> {
-    this.saveQueryProgressState.inProgress();
-    try {
-      const query = this.buildQuery();
-      await onSaveQuery(query);
-    } catch (error) {
-      assertErrorThrown(error);
-      this.applicationStore.notificationService.notifyError(
-        `Can't save query: ${error.message}`,
-      );
-    } finally {
-      this.saveQueryProgressState.complete();
-    }
-  }
-
   *compileQuery(): GeneratorFn<void> {
     if (!this.textEditorState.mode) {
       this.queryCompileState.inProgress();

package/src/stores/QueryBuilder_LegendApplicationPlugin_Extension.ts

@@ -17,6 +17,7 @@
 import type { LegendApplicationPlugin } from '@finos/legend-application';
 import type { QueryBuilderState } from './QueryBuilderState.js';
 import type { QuerySearchSpecification } from '@finos/legend-graph';
+import type { DatasetAccessInfo } from './data-access/DataAccessState.js';
 
 export type LoadQueryFilterOption = {
   key: string;
@@ -27,10 +28,19 @@ export type LoadQueryFilterOption = {
   ) => QuerySearchSpecification;
 };
 
+export type DatasetEntitlementAccessReportActionConfiguration = {
+  renderer: (info: DatasetAccessInfo) => React.ReactNode;
+};
+
 export interface QueryBuilder_LegendApplicationPlugin_Extension
   extends LegendApplicationPlugin {
   /**
    * Get the list of filter options for query loader.
    */
   getExtraLoadQueryFilterOptions?(): LoadQueryFilterOption[];
+
+  /**
+   * Get the list of dataset entitlement access report action configurations.
+   */
+  getExtraDatasetEntitlementAccessNotGrantedReportActionConfigurations?(): DatasetEntitlementAccessReportActionConfiguration[];
 }

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/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",
@@ -75,6 +76,7 @@
     "./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",
@@ -218,6 +220,7 @@
     "./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",