@finos/legend-query-builder 4.17.100 → 4.18.1

package/src/stores/workflows/accessor/AccessorQueryBuilderState.ts

@@ -0,0 +1,200 @@
+/**
+ * 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 GraphManagerState,
+  type PackageableRuntime,
+  type AccessorOwner,
+  type Accessor,
+  IngestDefinition,
+  Database,
+  PackageableElementExplicitReference,
+  RuntimePointer,
+  type TEMPORARY_IngestContent,
+} from '@finos/legend-graph';
+import { QueryBuilderState } from '../../QueryBuilderState.js';
+import type { GenericLegendApplicationStore } from '@finos/legend-application';
+import type {
+  QueryBuilderWorkflowState,
+  QueryBuilderActionConfig,
+} from '../../query-workflow/QueryBuilderWorkFlowState.js';
+import type { QueryBuilderConfig } from '../../../graph-manager/QueryBuilderConfig.js';
+import { renderAccessorQueryBuilderSetupPanelContent } from '../../../components/workflows/AccessorQueryBuilder.js';
+import { action, computed, makeObservable } from 'mobx';
+import type { QueryableSourceInfo } from '@finos/legend-storage';
+import { buildElementOption } from '@finos/legend-lego/graph-editor';
+import { getCompatibleRuntimesFromAccessorOwner } from './AccessorQueryBuilderHelper.js';
+import { QueryBuilderEmbeddedFromExecutionContextState } from '../../QueryBuilderExecutionContextState.js';
+import { QueryBuilderTDSState } from '../../fetch-structure/tds/QueryBuilderTDSState.js';
+
+export interface AccessorOwnerOption {
+  label: string;
+  value: AccessorOwner;
+}
+
+export class AccessorQueryBuilderState extends QueryBuilderState {
+  override TEMPORARY__setupPanelContentRenderer = (): React.ReactNode =>
+    renderAccessorQueryBuilderSetupPanelContent(this);
+
+  constructor(
+    applicationStore: GenericLegendApplicationStore,
+    accessor: Accessor | undefined,
+    graphManagerState: GraphManagerState,
+    workflow: QueryBuilderWorkflowState,
+    actionConfig: QueryBuilderActionConfig,
+    config?: QueryBuilderConfig | undefined,
+    sourceInfo?: QueryableSourceInfo | undefined,
+  ) {
+    super(applicationStore, graphManagerState, workflow, config, sourceInfo);
+    makeObservable(this, {
+      changeAccessorOwner: action,
+      changeAccessor: action,
+      accessorOwnerOptions: computed,
+      accessorLabel: computed,
+      compatibleRuntimes: computed,
+    });
+    this.workflowState.updateActionConfig(actionConfig);
+    if (accessor) {
+      this.changeSourceElement(accessor);
+    }
+    this.configureFilterPanelsForAccessor();
+    // force from.
+    this.executionContextState =
+      new QueryBuilderEmbeddedFromExecutionContextState(this);
+  }
+
+  // we will not include data product as it is own state
+  get accessorOwners(): AccessorOwner[] {
+    return [
+      ...this.graphManagerState.graph.ingests,
+      ...this.graphManagerState.usableDatabases,
+    ];
+  }
+
+  get accessorLabel(): string {
+    return this.sourceAccessor?.accessorLabel ?? 'Accessor';
+  }
+
+  get accessorOwnerOptions(): AccessorOwnerOption[] {
+    return this.accessorOwners.map(buildElementOption);
+  }
+
+  get selectedAccessorOwner(): AccessorOwner | undefined {
+    return this.sourceAccessor?.parentElement;
+  }
+
+  get accessors(): {
+    schemaName?: string | undefined;
+    tableName: string;
+  }[] {
+    if (this.selectedAccessorOwner instanceof IngestDefinition) {
+      const content = this.selectedAccessorOwner
+        .content as unknown as TEMPORARY_IngestContent;
+      return (
+        content.datasets?.map((e) => ({
+          tableName: e.name,
+        })) ?? []
+      );
+    } else if (this.selectedAccessorOwner instanceof Database) {
+      return this.selectedAccessorOwner.schemas.flatMap((schema) =>
+        schema.tables.map((table) => ({
+          schemaName: schema.name,
+          tableName: table.name,
+        })),
+      );
+    }
+    return [];
+  }
+
+  get accessorsOptions(): {
+    label: string;
+    value: { schemaName?: string | undefined; tableName: string };
+  }[] {
+    return this.accessors.map((accessor) => ({
+      label: accessor.schemaName
+        ? `${accessor.schemaName}.${accessor.tableName}`
+        : accessor.tableName,
+      value: accessor,
+    }));
+  }
+
+  get compatibleRuntimes(): PackageableRuntime[] {
+    const owner = this.selectedAccessorOwner;
+    if (!owner) {
+      return [];
+    }
+    return getCompatibleRuntimesFromAccessorOwner(
+      owner,
+      this.graphManagerState,
+    );
+  }
+
+  override get requiresMappingForExecution(): boolean {
+    return false;
+  }
+
+  /**
+   * In accessor mode, the filter panel does not support relation columns,
+   * so we hide it and show the post-filter panel instead.
+   */
+  private configureFilterPanelsForAccessor(): void {
+    this.filterState.setShowPanel(false);
+    const tdsState = this.fetchStructureState.implementation;
+    if (tdsState instanceof QueryBuilderTDSState) {
+      tdsState.setShowPostFilterPanel(true);
+    }
+  }
+
+  changeAccessorOwner(accessorOwner: AccessorOwner): void {
+    const accessor =
+      this.graphManagerState.graphManager.createAccessorFromPackageableElement(
+        accessorOwner,
+        this.graphManagerState.graph,
+      );
+    if (accessor) {
+      this.changeSourceElement(accessor);
+      this.configureFilterPanelsForAccessor();
+    }
+  }
+
+  changeAccessor(value: {
+    schemaName?: string | undefined;
+    tableName: string;
+  }): void {
+    const owner = this.selectedAccessorOwner;
+    if (owner) {
+      const accessor =
+        this.graphManagerState.graphManager.createAccessorFromPackageableElement(
+          owner,
+          this.graphManagerState.graph,
+          {
+            schemaName: value.schemaName,
+            tableName: value.tableName,
+          },
+        );
+      if (accessor) {
+        this.changeSourceElement(accessor);
+        this.configureFilterPanelsForAccessor();
+      }
+    }
+  }
+
+  changeSelectedRuntime(val: PackageableRuntime): void {
+    this.changeRuntime(
+      new RuntimePointer(PackageableElementExplicitReference.create(val)),
+    );
+  }
+}

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

@@ -40,8 +40,19 @@ import {
   type QueryExecutionContext,
   QueryDataProductNativeExecutionContext,
   QueryDataProductModelAccessExecutionContext,
+  QueryDataProductLakehouseExecutionContext,
+  LakehouseAccessPoint,
   type RawLambda,
   buildRawLambdaFromLambdaFunction,
+  type Accessor,
+  type RelationTypeMetadata,
+  DataProductAccessor,
+  RelationType,
+  RelationColumn,
+  GenericType,
+  GenericTypeExplicitReference,
+  findLakehouseAccessPointGroup,
+  type PureModel,
 } from '@finos/legend-graph';
 import { QueryBuilderState } from '../../QueryBuilderState.js';
 
@@ -68,6 +79,35 @@ 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 +144,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 +167,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 +249,7 @@ export class ModelAccessPointDataProductExecutionState extends DataProductExecut
     return this.exectionValue.featuredElements;
   }
 
-  get showRuntimeOptions(): boolean {
+  override get showRuntimeOptions(): boolean {
     return this.compatibleRuntimes.length > 1;
   }
 
@@ -207,6 +260,46 @@ 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>;
@@ -218,7 +311,7 @@ export class DataProductQueryBuilderState extends QueryBuilderState {
   dataProduct: DataProduct;
   dataProductArtifact: V1_DataProductArtifact | undefined;
   executionState: DataProductExecutionState<
-    NativeModelExecutionContext | ModelAccessPointGroup
+    NativeModelExecutionContext | ModelAccessPointGroup | LakehouseAccessPoint
   >;
   entities: DepotEntityWithOrigin[] | undefined;
 
@@ -234,7 +327,10 @@ 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?:
@@ -255,8 +351,12 @@ export class DataProductQueryBuilderState extends QueryBuilderState {
       isProductLinkable: computed,
       isNativeMode: computed,
       isModelAccessPointGroupMode: computed,
+      isLakehouseMode: computed,
       showExecutionContextOptions: computed,
       showModelAccessPointGroupSelector: computed,
+      showExecutionIdSelector: computed,
+      executionIdOptions: computed,
+      selectedExecutionIdOption: computed,
       selectedExecOption: computed,
       selectedModelAccessPointGroupOption: computed,
       usableClasses: computed,
@@ -277,11 +377,16 @@ 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);
   }
 
   get isProductLinkable(): boolean {
@@ -298,6 +403,10 @@ export class DataProductQueryBuilderState extends QueryBuilderState {
     );
   }
 
+  get isLakehouseMode(): boolean {
+    return this.executionState instanceof LakehouseDataProductExecutionState;
+  }
+
   get showExecutionContextOptions(): boolean {
     return this.isNativeMode && this.execOptions.length > 1;
   }
@@ -309,6 +418,75 @@ export class DataProductQueryBuilderState extends QueryBuilderState {
     );
   }
 
+  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;
+    }
+    await this.changeExecutionState(val);
+    await this.propagateExecutionContextChange();
+    if (val instanceof NativeModelExecutionContext) {
+      this.onExecutionContextChange?.(val);
+    }
+  }
+
   get selectedExecOption():
     | { label: string; value: NativeModelExecutionContext }
     | undefined {
@@ -317,6 +495,13 @@ export class DataProductQueryBuilderState extends QueryBuilderState {
       : undefined;
   }
 
+  override get requiresMappingForExecution(): boolean {
+    if (this.executionState instanceof LakehouseDataProductExecutionState) {
+      return false;
+    }
+    return true;
+  }
+
   get selectedModelAccessPointGroupOption():
     | ModelAccessPointGroupOption
     | undefined {
@@ -390,6 +575,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 +595,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,7 +622,11 @@ export class DataProductQueryBuilderState extends QueryBuilderState {
 
   initWithDataProduct(
     dataProduct: DataProduct,
-    preResolvedState?: NativeModelExecutionContext | ModelAccessPointGroup,
+    accessor: Accessor | undefined,
+    preResolvedState?:
+      | NativeModelExecutionContext
+      | ModelAccessPointGroup
+      | LakehouseAccessPoint,
   ): void {
     try {
       const execValue =
@@ -439,8 +635,13 @@ export class DataProductQueryBuilderState extends QueryBuilderState {
       this.executionState =
         execValue instanceof NativeModelExecutionContext
           ? new NativeModelDataProductExecutionState(execValue, this)
-          : new ModelAccessPointDataProductExecutionState(execValue, this);
-      this.changeMapping(this.executionState.mapping);
+          : execValue instanceof LakehouseAccessPoint
+            ? new LakehouseDataProductExecutionState(execValue, this)
+            : new ModelAccessPointDataProductExecutionState(execValue, this);
+      const mapping = this.executionState.mapping;
+      if (mapping) {
+        this.changeMapping(mapping);
+      }
       if (this.executionState instanceof NativeModelDataProductExecutionState) {
         const runtime = guaranteeNonNullable(
           this.executionState.exectionValue.runtime,
@@ -453,19 +654,37 @@ 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.class || !compatibleClasses.includes(this.class)) {
-        const possibleNewClass = compatibleClasses[0];
-        if (possibleNewClass) {
-          this.changeClass(possibleNewClass);
+      if (mapping) {
+        const compatibleClasses = resolveUsableDataProductClasses(
+          this.activeFeaturedElements,
+          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);
+          }
         }
       }
     } catch (error) {
@@ -489,12 +708,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 +860,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),
+      )
     );
   }
 
@@ -641,8 +892,8 @@ export class DataProductQueryBuilderState extends QueryBuilderState {
         this.graphManagerState,
         undefined,
       );
-      if (this.class && !classes.includes(this.class)) {
-        this.setClass(classes[0]);
+      if (this.sourceClass && !classes.includes(this.sourceClass)) {
+        this.setSourceElement(classes[0]);
       }
     }
   }

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",
@@ -226,6 +228,8 @@
     "./src/stores/workflows/FunctionQueryBuilderState.ts",
     "./src/stores/workflows/MappingQueryBuilderState.ts",
     "./src/stores/workflows/ServiceQueryBuilderState.ts",
+    "./src/stores/workflows/accessor/AccessorQueryBuilderHelper.ts",
+    "./src/stores/workflows/accessor/AccessorQueryBuilderState.ts",
     "./src/stores/workflows/dataProduct/DataProductQueryBuilderState.ts",
     "./src/components/QueryBuilder.tsx",
     "./src/components/QueryBuilderConstantExpressionPanel.tsx",
@@ -264,6 +268,7 @@
     "./src/components/explorer/QueryBuilderFunctionsExplorerPanel.tsx",
     "./src/components/explorer/QueryBuilderMilestoningParameterEditor.tsx",
     "./src/components/explorer/QueryBuilderPropertySearchPanel.tsx",
+    "./src/components/explorer/QueryBuilderRelationExplorerPanel.tsx",
     "./src/components/fetch-structure/QueryBuilderAggParam.tsx",
     "./src/components/fetch-structure/QueryBuilderFetchStructurePanel.tsx",
     "./src/components/fetch-structure/QueryBuilderGraphFetchTreePanel.tsx",
@@ -294,6 +299,7 @@
     "./src/components/sql-playground/SQLPlaygroundExplorer.tsx",
     "./src/components/sql-playground/SQLPlaygroundGrid.tsx",
     "./src/components/sql-playground/SQLPlaygroundPanel.tsx",
+    "./src/components/workflows/AccessorQueryBuilder.tsx",
     "./src/components/workflows/ClassQueryBuilder.tsx",
     "./src/components/workflows/DataProductQueryBuilder.tsx",
     "./src/components/workflows/MappingQueryBuilder.tsx",