@finos/legend-query-builder 4.18.0 → 4.18.2

package/src/stores/workflows/dataProduct/DataProductQueryBuilderState.ts

@@ -32,6 +32,7 @@ import {
   SimpleFunctionExpression,
   InstanceValue,
   Multiplicity,
+  type MappingModelCoverageAnalysisResult,
   extractElementNameFromPath,
   SUPPORTED_FUNCTIONS,
   PackageableElementExplicitReference,
@@ -40,8 +41,21 @@ import {
   type QueryExecutionContext,
   QueryDataProductNativeExecutionContext,
   QueryDataProductModelAccessExecutionContext,
+  QueryDataProductLakehouseExecutionContext,
+  LakehouseAccessPoint,
   type RawLambda,
   buildRawLambdaFromLambdaFunction,
+  type Accessor,
+  type RelationTypeMetadata,
+  DataProductAccessor,
+  RelationType,
+  RelationColumn,
+  GenericType,
+  GenericTypeExplicitReference,
+  findLakehouseAccessPointGroup,
+  type PureModel,
+  DataProductAccessType,
+  LegendSDLC,
 } from '@finos/legend-graph';
 import { QueryBuilderState } from '../../QueryBuilderState.js';
 
@@ -63,11 +77,41 @@ import { action, computed, flow, makeObservable, observable } from 'mobx';
 import {
   DepotEntityWithOrigin,
   type QueryableSourceInfo,
+  type ProjectGAVCoordinates,
 } from '@finos/legend-storage';
 import { compareLabelFn } from '@finos/legend-art';
 import { QueryBuilderEmbeddedFromExecutionContextState } from '../../QueryBuilderExecutionContextState.js';
 import { buildLambdaFunction } from '../../QueryBuilderValueSpecificationBuilder.js';
 
+export const buildDataProductAccessor = (
+  relationMetadata: RelationTypeMetadata,
+  dataProduct: DataProduct,
+  accessPoint: LakehouseAccessPoint,
+  graph: PureModel,
+): DataProductAccessor => {
+  const relationType = new RelationType(accessPoint.title ?? accessPoint.id);
+  relationType.columns = relationMetadata.columns.map(
+    (col) =>
+      new RelationColumn(
+        col.name,
+        GenericTypeExplicitReference.create(
+          new GenericType(graph.getType(col.type)),
+        ),
+      ),
+  );
+  const groupResult = findLakehouseAccessPointGroup(
+    dataProduct,
+    accessPoint.id,
+  );
+  return new DataProductAccessor(
+    dataProduct.path,
+    groupResult?.group.id,
+    accessPoint.id,
+    relationType,
+    dataProduct,
+  );
+};
+
 export type DataProductOption = {
   label: string;
   value: DepotEntityWithOrigin;
@@ -104,6 +148,15 @@ export const buildModelAccessPointGroupOption = (
   value,
 });
 
+export type ExecutionIdOption = {
+  label: string;
+  tag: string;
+  value:
+    | NativeModelExecutionContext
+    | ModelAccessPointGroup
+    | LakehouseAccessPoint;
+};
+
 export abstract class DataProductExecutionState<T> {
   readonly queryBuilderState: DataProductQueryBuilderState;
   exectionValue: T;
@@ -118,10 +171,14 @@ export abstract class DataProductExecutionState<T> {
 
   abstract get label(): string;
 
-  abstract get mapping(): Mapping;
+  abstract get mapping(): Mapping | undefined;
 
   abstract get featuredElements(): DataProductElementScope[] | undefined;
 
+  get showRuntimeOptions(): boolean {
+    return false;
+  }
+
   get selectedOption(): { label: string; value: T } {
     return {
       label: this.label,
@@ -196,7 +253,7 @@ export class ModelAccessPointDataProductExecutionState extends DataProductExecut
     return this.exectionValue.featuredElements;
   }
 
-  get showRuntimeOptions(): boolean {
+  override get showRuntimeOptions(): boolean {
     return this.compatibleRuntimes.length > 1;
   }
 
@@ -207,20 +264,61 @@ export class ModelAccessPointDataProductExecutionState extends DataProductExecut
   }
 }
 
+export class LakehouseDataProductExecutionState extends DataProductExecutionState<LakehouseAccessPoint> {
+  selectedRuntime: PackageableRuntime | undefined;
+  adhocRuntime = false;
+  constructor(
+    executionState: LakehouseAccessPoint,
+    queryBuilderState: DataProductQueryBuilderState,
+  ) {
+    super(executionState, queryBuilderState);
+    makeObservable(this, {});
+    this.selectedRuntime = this.compatibleRuntimes[0];
+  }
+
+  changeSelectedRuntime(val: PackageableRuntime): void {
+    this.selectedRuntime = val;
+    this.queryBuilderState.changeRuntime(val);
+  }
+
+  override get label(): string {
+    return this.exectionValue.title ?? this.exectionValue.id;
+  }
+
+  get mapping(): Mapping | undefined {
+    return undefined;
+  }
+
+  get featuredElements(): DataProductElementScope[] | undefined {
+    return undefined;
+  }
+
+  get compatibleRuntimes(): PackageableRuntime[] {
+    return this.queryBuilderState.graphManagerState.usableRuntimes.filter(
+      (runtime) => runtime.runtimeValue instanceof LakehouseRuntime,
+    );
+  }
+
+  override get showRuntimeOptions(): boolean {
+    return this.compatibleRuntimes.length > 1;
+  }
+}
+
 export class DataProductQueryBuilderState extends QueryBuilderState {
   readonly onClassChange?: ((val: Class) => void) | undefined;
   readonly onDataProductChange?: (val: DepotEntityWithOrigin) => Promise<void>;
-  readonly onExecutionContextChange?:
-    | ((val: NativeModelExecutionContext) => void)
-    | undefined;
 
   loadDataProductModelState = ActionState.create();
   dataProduct: DataProduct;
   dataProductArtifact: V1_DataProductArtifact | undefined;
   executionState: DataProductExecutionState<
-    NativeModelExecutionContext | ModelAccessPointGroup
+    NativeModelExecutionContext | ModelAccessPointGroup | LakehouseAccessPoint
   >;
   entities: DepotEntityWithOrigin[] | undefined;
+  mappingToMappingCoverageResult?: Map<
+    string,
+    MappingModelCoverageAnalysisResult
+  >;
 
   prioritizeEntityFunc?: ((val: DepotEntityWithOrigin) => boolean) | undefined;
 
@@ -234,12 +332,12 @@ export class DataProductQueryBuilderState extends QueryBuilderState {
     dataProduct: DataProduct,
     artifact: V1_DataProductArtifact | undefined,
     actionConfig: QueryBuilderActionConfig,
-    executionState: NativeModelExecutionContext | ModelAccessPointGroup,
+    executionState:
+      | NativeModelExecutionContext
+      | ModelAccessPointGroup
+      | LakehouseAccessPoint,
     prioritizeEntityFunc: ((val: DepotEntityWithOrigin) => boolean) | undefined,
     onDataProductChange: (val: DepotEntityWithOrigin) => Promise<void>,
-    onExecutionContextChange?:
-      | ((val: NativeModelExecutionContext) => void)
-      | undefined,
     onClassChange?: ((val: Class) => void) | undefined,
     config?: QueryBuilderConfig | undefined,
     sourceInfo?: QueryableSourceInfo | undefined,
@@ -255,8 +353,17 @@ export class DataProductQueryBuilderState extends QueryBuilderState {
       isProductLinkable: computed,
       isNativeMode: computed,
       isModelAccessPointGroupMode: computed,
+      isLakehouseMode: computed,
       showExecutionContextOptions: computed,
       showModelAccessPointGroupSelector: computed,
+      showExecutionIdSelector: computed,
+      executionIdOptions: computed,
+      selectedExecutionIdOption: computed,
+      hasNativeModelAccess: computed,
+      hasBothAccessModes: computed,
+      showContextSelector: computed,
+      allContextOptions: computed,
+      selectedContextOption: computed,
       selectedExecOption: computed,
       selectedModelAccessPointGroupOption: computed,
       usableClasses: computed,
@@ -277,11 +384,36 @@ export class DataProductQueryBuilderState extends QueryBuilderState {
     this.executionState =
       executionState instanceof NativeModelExecutionContext
         ? new NativeModelDataProductExecutionState(executionState, this)
-        : new ModelAccessPointDataProductExecutionState(executionState, this);
+        : executionState instanceof LakehouseAccessPoint
+          ? new LakehouseDataProductExecutionState(executionState, this)
+          : new ModelAccessPointDataProductExecutionState(executionState, this);
     this.prioritizeEntityFunc = prioritizeEntityFunc;
     this.onDataProductChange = onDataProductChange;
-    this.onExecutionContextChange = onExecutionContextChange;
     this.onClassChange = onClassChange;
+    // force from.
+    this.executionContextState =
+      new QueryBuilderEmbeddedFromExecutionContextState(this);
+  }
+
+  async prepareAccessForExecution(): Promise<void> {
+    if (this.executionState instanceof NativeModelDataProductExecutionState) {
+      const runtime = this.executionState.exectionValue.runtime;
+      if (runtime) {
+        this.changeRuntime(new RuntimePointer(runtime));
+      }
+    } else if (
+      this.executionState instanceof
+        ModelAccessPointDataProductExecutionState &&
+      this.executionState.selectedRuntime
+    ) {
+      this.changeRuntime(
+        new RuntimePointer(
+          PackageableElementExplicitReference.create(
+            this.executionState.selectedRuntime,
+          ),
+        ),
+      );
+    }
   }
 
   get isProductLinkable(): boolean {
@@ -298,6 +430,10 @@ export class DataProductQueryBuilderState extends QueryBuilderState {
     );
   }
 
+  get isLakehouseMode(): boolean {
+    return this.executionState instanceof LakehouseDataProductExecutionState;
+  }
+
   get showExecutionContextOptions(): boolean {
     return this.isNativeMode && this.execOptions.length > 1;
   }
@@ -308,6 +444,105 @@ export class DataProductQueryBuilderState extends QueryBuilderState {
       this.modelAccessPointGroupOptions.length > 1
     );
   }
+  get hasNativeModelAccess(): boolean {
+    return this.dataProduct.nativeModelAccess !== undefined;
+  }
+
+  get hasBothAccessModes(): boolean {
+    return this.hasModelAccessPointGroups && this.hasNativeModelAccess;
+  }
+
+  // showContextSelector / allContextOptions / selectedContextOption are aliases
+  // over the upstream ExecutionIdOption API so existing UI code keeps working.
+  get showContextSelector(): boolean {
+    return this.showExecutionIdSelector;
+  }
+
+  get allContextOptions(): ExecutionIdOption[] {
+    return this.executionIdOptions;
+  }
+
+  get selectedContextOption(): ExecutionIdOption | undefined {
+    return this.selectedExecutionIdOption;
+  }
+
+  get executionIdOptions(): ExecutionIdOption[] {
+    const nativeOptions: ExecutionIdOption[] = (
+      this.dataProduct.nativeModelAccess?.nativeModelExecutionContexts ?? []
+    ).map((ctx) => ({
+      label: ctx.key,
+      tag: 'NATIVE',
+      value: ctx,
+    }));
+    const modelOptions: ExecutionIdOption[] = this.modelAccessPointGroups.map(
+      (group) => ({
+        label: group.title ?? group.id,
+        tag: 'MODEL',
+        value: group,
+      }),
+    );
+    const lakehouseOptions: ExecutionIdOption[] =
+      this.dataProduct.accessPointGroups
+        .flatMap((group) => group.accessPoints)
+        .filter(filterByType(LakehouseAccessPoint))
+        .map((ap) => ({
+          label: ap.title ?? ap.id,
+          tag: 'LAKEHOUSE',
+          value: ap,
+        }));
+    return [...modelOptions, ...lakehouseOptions, ...nativeOptions].sort(
+      compareLabelFn,
+    );
+  }
+
+  get selectedExecutionIdOption(): ExecutionIdOption | undefined {
+    const state = this.executionState;
+    if (state instanceof NativeModelDataProductExecutionState) {
+      return {
+        label: state.exectionValue.key,
+        tag: 'NATIVE',
+        value: state.exectionValue,
+      };
+    } else if (state instanceof ModelAccessPointDataProductExecutionState) {
+      return {
+        label: state.exectionValue.title ?? state.exectionValue.id,
+        tag: 'MODEL',
+        value: state.exectionValue,
+      };
+    } else if (state instanceof LakehouseDataProductExecutionState) {
+      return {
+        label: state.exectionValue.title ?? state.exectionValue.id,
+        tag: 'LAKEHOUSE',
+        value: state.exectionValue,
+      };
+    }
+    return undefined;
+  }
+
+  get showExecutionIdSelector(): boolean {
+    return this.executionIdOptions.length > 1;
+  }
+
+  async changeExecutionId(option: ExecutionIdOption): Promise<void> {
+    const val = option.value;
+    if (val === this.executionState.exectionValue) {
+      return;
+    }
+    const switchingToModel = val instanceof ModelAccessPointGroup;
+    const switchingToNative = val instanceof NativeModelExecutionContext;
+    const wasModeSwitch =
+      (switchingToModel && this.isNativeMode) ||
+      (switchingToNative && this.isModelAccessPointGroupMode);
+
+    if (wasModeSwitch) {
+      this.changeHistoryState.querySnapshotBuffer = [];
+      this.changeHistoryState.pointer = -1;
+      this.changeHistoryState.setCurrentQuery(undefined);
+    }
+
+    await this.changeExecutionState(val);
+    await this.propagateExecutionContextChange();
+  }
 
   get selectedExecOption():
     | { label: string; value: NativeModelExecutionContext }
@@ -317,6 +552,13 @@ export class DataProductQueryBuilderState extends QueryBuilderState {
       : undefined;
   }
 
+  override get requiresMappingForExecution(): boolean {
+    if (this.executionState instanceof LakehouseDataProductExecutionState) {
+      return false;
+    }
+    return true;
+  }
+
   get selectedModelAccessPointGroupOption():
     | ModelAccessPointGroupOption
     | undefined {
@@ -338,29 +580,6 @@ export class DataProductQueryBuilderState extends QueryBuilderState {
       : [];
   }
 
-  changeNativeExecutionContext(val: NativeModelExecutionContext): void {
-    if (this.isNativeMode && val === this.executionState.exectionValue) {
-      return;
-    }
-    this.setExecutionState(val);
-    this.propagateExecutionContextChange()
-      .then(() => this.onExecutionContextChange?.(val))
-      .catch(this.applicationStore.alertUnhandledError);
-  }
-
-  changeModelAccessPointGroupValue(val: ModelAccessPointGroup): void {
-    if (
-      this.isModelAccessPointGroupMode &&
-      val === this.executionState.exectionValue
-    ) {
-      return;
-    }
-    this.setExecutionState(val);
-    this.propagateExecutionContextChange().catch(
-      this.applicationStore.alertUnhandledError,
-    );
-  }
-
   override buildQueryForPersistence(): RawLambda {
     if (!this.isQuerySupported) {
       return this.buildQuery();
@@ -390,6 +609,13 @@ export class DataProductQueryBuilderState extends QueryBuilderState {
       execContext.dataProductPath = this.dataProduct.path;
       execContext.accessPointGroupId = this.executionState.exectionValue.id;
       return execContext;
+    } else if (
+      this.executionState instanceof LakehouseDataProductExecutionState
+    ) {
+      const execContext = new QueryDataProductLakehouseExecutionContext();
+      execContext.dataProductPath = this.dataProduct.path;
+      execContext.accessPointId = this.executionState.exectionValue.id;
+      return execContext;
     }
     return super.getQueryExecutionContext();
   }
@@ -403,7 +629,7 @@ export class DataProductQueryBuilderState extends QueryBuilderState {
           val.path,
         );
       if (dataProduct) {
-        this.initWithDataProduct(dataProduct);
+        this.initWithDataProduct(dataProduct, undefined, undefined);
         this.loadDataProductModelState.pass();
       } else if (this.onDataProductChange) {
         // data product not in current graph — trigger full rebuild
@@ -430,17 +656,21 @@ export class DataProductQueryBuilderState extends QueryBuilderState {
 
   initWithDataProduct(
     dataProduct: DataProduct,
-    preResolvedState?: NativeModelExecutionContext | ModelAccessPointGroup,
+    accessor: Accessor | undefined,
+    preResolvedState?:
+      | NativeModelExecutionContext
+      | ModelAccessPointGroup
+      | LakehouseAccessPoint,
   ): void {
     try {
       const execValue =
         preResolvedState ?? resolveDataProductExecutionState(dataProduct);
       this.dataProduct = dataProduct;
-      this.executionState =
-        execValue instanceof NativeModelExecutionContext
-          ? new NativeModelDataProductExecutionState(execValue, this)
-          : new ModelAccessPointDataProductExecutionState(execValue, this);
-      this.changeMapping(this.executionState.mapping);
+      this.setExecutionState(execValue);
+      const mapping = this.executionState.mapping;
+      if (mapping) {
+        this.changeMapping(mapping);
+      }
       if (this.executionState instanceof NativeModelDataProductExecutionState) {
         const runtime = guaranteeNonNullable(
           this.executionState.exectionValue.runtime,
@@ -453,19 +683,44 @@ export class DataProductQueryBuilderState extends QueryBuilderState {
         this.executionState.selectedRuntime instanceof PackageableRuntime
       ) {
         this.changeRuntime(this.executionState.selectedRuntime);
+      } else if (
+        this.executionState instanceof LakehouseDataProductExecutionState &&
+        accessor &&
+        this.executionState.selectedRuntime instanceof PackageableRuntime
+      ) {
+        this.setSourceElement(accessor);
+        this.changeRuntime(
+          new RuntimePointer(
+            PackageableElementExplicitReference.create(
+              this.executionState.selectedRuntime,
+            ),
+          ),
+        );
       }
-      const compatibleClasses = resolveUsableDataProductClasses(
-        this.activeFeaturedElements,
-        this.executionState.mapping,
-        this.graphManagerState,
-        undefined,
-      );
-      // if there is no chosen class or the chosen one is not compatible
-      // with the mapping then pick a compatible class if possible
-      if (!this.sourceClass || !compatibleClasses.includes(this.sourceClass)) {
-        const possibleNewClass = compatibleClasses[0];
-        if (possibleNewClass) {
-          this.changeSourceElement(possibleNewClass);
+      if (mapping) {
+        const coverageResult = this.mappingToMappingCoverageResult?.get(
+          mapping.path,
+        );
+        if (coverageResult) {
+          this.explorerState.mappingModelCoverageAnalysisResult =
+            coverageResult;
+        }
+        const compatibleClasses = resolveUsableDataProductClasses(
+          this.activeFeaturedElements,
+          mapping,
+          this.graphManagerState,
+          coverageResult,
+        );
+        // if there is no chosen class or the chosen one is not compatible
+        // with the mapping then pick a compatible class if possible
+        if (
+          !this.sourceClass ||
+          !compatibleClasses.includes(this.sourceClass)
+        ) {
+          const possibleNewClass = compatibleClasses[0];
+          if (possibleNewClass) {
+            this.changeSourceElement(possibleNewClass);
+          }
         }
       }
     } catch (error) {
@@ -489,12 +744,40 @@ export class DataProductQueryBuilderState extends QueryBuilderState {
   }
 
   setExecutionState(
-    val: NativeModelExecutionContext | ModelAccessPointGroup,
+    val:
+      | NativeModelExecutionContext
+      | ModelAccessPointGroup
+      | LakehouseAccessPoint,
   ): void {
     this.executionState =
       val instanceof NativeModelExecutionContext
         ? new NativeModelDataProductExecutionState(val, this)
-        : new ModelAccessPointDataProductExecutionState(val, this);
+        : val instanceof LakehouseAccessPoint
+          ? new LakehouseDataProductExecutionState(val, this)
+          : new ModelAccessPointDataProductExecutionState(val, this);
+  }
+
+  async changeExecutionState(
+    val:
+      | NativeModelExecutionContext
+      | ModelAccessPointGroup
+      | LakehouseAccessPoint,
+  ): Promise<void> {
+    this.setExecutionState(val);
+    if (val instanceof LakehouseAccessPoint) {
+      const relationMetadata =
+        await this.graphManagerState.graphManager.getLambdaRelationType(
+          val.func,
+          this.graphManagerState.graph,
+        );
+      const accessor = buildDataProductAccessor(
+        relationMetadata,
+        this.dataProduct,
+        val,
+        this.graphManagerState.graph,
+      );
+      this.setSourceElement(accessor);
+    }
   }
 
   get modelAccessPointGroups(): ModelAccessPointGroup[] {
@@ -613,7 +896,11 @@ export class DataProductQueryBuilderState extends QueryBuilderState {
       // contains model access point group
       this.dataProduct.accessPointGroups.filter(
         filterByType(ModelAccessPointGroup),
-      ).length > 0
+      ).length > 0 ||
+      // contains lakehouse access point
+      this.dataProduct.accessPointGroups.some((group) =>
+        group.accessPoints.some((ap) => ap instanceof LakehouseAccessPoint),
+      )
     );
   }
 
@@ -631,19 +918,87 @@ export class DataProductQueryBuilderState extends QueryBuilderState {
   ): Promise<void> {
     const currentMapping = this.executionContextState.mapping;
     const newMapping = this.activeMapping;
-    if (newMapping && newMapping !== currentMapping) {
-      this.changeMapping(newMapping, {
-        keepQueryContent: true,
-      });
-      const classes = resolveUsableDataProductClasses(
-        this.activeFeaturedElements,
-        newMapping,
-        this.graphManagerState,
-        undefined,
-      );
-      if (this.sourceClass && !classes.includes(this.sourceClass)) {
-        this.setSourceElement(classes[0]);
+    if (!newMapping || newMapping === currentMapping) {
+      return;
+    }
+
+    const coverageResult = this.mappingToMappingCoverageResult?.get(
+      newMapping.path,
+    );
+
+    if (coverageResult && this.dataProductArtifact) {
+      const origin = this.graphManagerState.graph.origin;
+      if (origin instanceof LegendSDLC) {
+        const newGraph = this.graphManagerState.createNewGraph();
+        const projectInfo: ProjectGAVCoordinates = {
+          groupId: origin.groupId,
+          artifactId: origin.artifactId,
+          versionId: origin.versionId,
+        };
+        let accessPointId: string;
+        let dataProductAccessType: DataProductAccessType;
+        if (
+          this.executionState instanceof NativeModelDataProductExecutionState
+        ) {
+          accessPointId = this.executionState.exectionValue.key;
+          dataProductAccessType = DataProductAccessType.NATIVE;
+        } else {
+          accessPointId = (
+            this.executionState as ModelAccessPointDataProductExecutionState
+          ).exectionValue.id;
+          dataProductAccessType = DataProductAccessType.MODEL;
+        }
+        const analysisResult =
+          await this.graphManagerState.graphManager.buildDataProductAnalysis(
+            this.dataProductArtifact,
+            this.dataProduct.path,
+            newGraph,
+            accessPointId,
+            dataProductAccessType,
+            projectInfo,
+          );
+        this.graphManagerState.graph = newGraph;
+
+        this.dataProduct = newGraph.getDataProduct(this.dataProduct.path);
+        this.setExecutionState(analysisResult.targetExecState);
+        if (analysisResult.dataProductAnalysis.mappingToMappingCoverageResult) {
+          this.mappingToMappingCoverageResult =
+            analysisResult.dataProductAnalysis.mappingToMappingCoverageResult;
+        }
+        const newCoverageResult = this.mappingToMappingCoverageResult?.get(
+          newMapping.path,
+        );
+        if (newCoverageResult) {
+          this.explorerState.mappingModelCoverageAnalysisResult =
+            newCoverageResult;
+        }
+      } else {
+        this.explorerState.mappingModelCoverageAnalysisResult = coverageResult;
+      }
+    } else if (coverageResult) {
+      this.explorerState.mappingModelCoverageAnalysisResult = coverageResult;
+    }
+
+    await this.prepareAccessForExecution();
+
+    this.changeMapping(newMapping, {
+      keepQueryContent: true,
+    });
+    const classes = resolveUsableDataProductClasses(
+      this.activeFeaturedElements,
+      newMapping,
+      this.graphManagerState,
+      this.explorerState.mappingModelCoverageAnalysisResult,
+    );
+    if (
+      !this.sourceClass ||
+      (!classes.includes(this.sourceClass) && classes.length)
+    ) {
+      const possibleNewClass = classes[0];
+      if (possibleNewClass) {
+        this.changeSourceElement(possibleNewClass);
       }
     }
+    this.explorerState.refreshTreeData();
   }
 }

package/tsconfig.json

@@ -106,6 +106,7 @@
     "./src/stores/QueryLoaderState.ts",
     "./src/stores/ServiceInfo.ts",
     "./src/stores/__test-utils__/QueryBuilderStateTestUtils.ts",
+    "./src/stores/__test-utils__/TEST_DATA__QueryBuilder_Accessors.ts",
     "./src/stores/data-access/DataAccessState.ts",
     "./src/stores/data-cube/QueryBuilderDataCubeEngine.ts",
     "./src/stores/data-cube/QueryBuilderDataCubeHelper.ts",
@@ -181,6 +182,7 @@
     "./src/stores/fetch-structure/tds/window/operators/QueryBuilderTDS_WindowOperator_Count.ts",
     "./src/stores/fetch-structure/tds/window/operators/QueryBuilderTDS_WindowOperator_Max.ts",
     "./src/stores/fetch-structure/tds/window/operators/QueryBuilderTDS_WindowOperator_Min.ts",
+    "./src/stores/fetch-structure/tds/window/operators/QueryBuilderTDS_WindowOperator_PercentRank.ts",
     "./src/stores/fetch-structure/tds/window/operators/QueryBuilderTDS_WindowOperator_Sum.ts",
     "./src/stores/fetch-structure/tds/window/operators/QueryBuilderTDS_WindowRankOperator_AverageRank.ts",
     "./src/stores/fetch-structure/tds/window/operators/QueryBuilderTDS_WindowRankOperator_DenseRank.ts",