@finos/legend-query-builder 4.14.30 → 4.14.31

package/src/components/fetch-structure/QueryBuilderFetchStructurePanel.tsx

@@ -32,6 +32,7 @@ import { QueryBuilderGraphFetchTreeState } from '../../stores/fetch-structure/gr
 import { QueryBuilderPanelIssueCountBadge } from '../shared/QueryBuilderPanelIssueCountBadge.js';
 import { FETCH_STRUCTURE_IMPLEMENTATION } from '../../stores/fetch-structure/QueryBuilderFetchStructureImplementationState.js';
 import { QUERY_BUILDER_TEST_ID } from '../../__lib__/QueryBuilderTesting.js';
+import { onChangeFetchStructureImplementation } from '../../stores/fetch-structure/QueryBuilderFetchStructureState.js';
 
 const QueryBuilderFetchStructureEditor = observer(
   (props: { queryBuilderState: QueryBuilderState }) => {
@@ -68,24 +69,18 @@ export const QueryBuilderFetchStructurePanel = observer(
   (props: { queryBuilderState: QueryBuilderState }) => {
     const { queryBuilderState } = props;
     const fetchStructureState = queryBuilderState.fetchStructureState;
-
-    const onChangeFetchStructureImplementation =
-      (implementationType: FETCH_STRUCTURE_IMPLEMENTATION): (() => void) =>
-      (): void => {
-        if (fetchStructureState.implementation.type !== implementationType) {
-          fetchStructureState.implementation.checkBeforeChangingImplementation(
-            () => {
-              fetchStructureState.changeImplementation(implementationType);
-            },
-          );
-        }
-      };
+    const fetchConfig =
+      queryBuilderState.workflowState.getFetchStructureLayoutConfig(
+        queryBuilderState,
+      );
 
     return (
       <Panel data-testid={QUERY_BUILDER_TEST_ID.QUERY_BUILDER_FETCH_STRUCTURE}>
         <PanelHeader>
           <div className="panel__header__title">
-            <div className="panel__header__title__label">fetch structure</div>
+            <div className="panel__header__title__label">
+              {fetchConfig.label}
+            </div>
             {fetchStructureState.implementation.fetchStructureValidationIssues
               .length !== 0 && (
               <QueryBuilderPanelIssueCountBadge
@@ -96,22 +91,27 @@ export const QueryBuilderFetchStructurePanel = observer(
               />
             )}
           </div>
-          <PanelHeaderActions>
-            <div className="query-builder__fetch__structure__modes">
-              {Object.values(FETCH_STRUCTURE_IMPLEMENTATION).map((type) => (
-                <button
-                  onClick={onChangeFetchStructureImplementation(type)}
-                  className={clsx('query-builder__fetch__structure__mode', {
-                    'query-builder__fetch__structure__mode--selected':
-                      type === fetchStructureState.implementation.type,
-                  })}
-                  key={type}
-                >
-                  {prettyCONSTName(type)}
-                </button>
-              ))}
-            </div>
-          </PanelHeaderActions>
+          {fetchConfig.showInFetchPanel ? (
+            <PanelHeaderActions>
+              <div className="query-builder__fetch__structure__modes">
+                {Object.values(FETCH_STRUCTURE_IMPLEMENTATION).map((type) => (
+                  <button
+                    onClick={onChangeFetchStructureImplementation(
+                      type,
+                      fetchStructureState,
+                    )}
+                    className={clsx('query-builder__fetch__structure__mode', {
+                      'query-builder__fetch__structure__mode--selected':
+                        type === fetchStructureState.implementation.type,
+                    })}
+                    key={type}
+                  >
+                    {prettyCONSTName(type)}
+                  </button>
+                ))}
+              </div>
+            </PanelHeaderActions>
+          ) : null}
         </PanelHeader>
         <QueryBuilderFetchStructureEditor
           queryBuilderState={queryBuilderState}

package/src/graph/QueryBuilderMetaModelConst.ts

@@ -24,6 +24,8 @@ export enum QUERY_BUILDER_PURE_PATH {
   DURATION_UNIT = 'meta::pure::functions::date::DurationUnit',
   DAY_OF_WEEK = 'meta::pure::functions::date::DayOfWeek',
 
+  // RELATION
+  RELATION = 'meta::pure::metamodel::relation::Relation',
   // serialization
   SERIALIZE_CONFIG = 'meta::pure::graphFetch::execution::AlloySerializationConfig',
 }
@@ -31,6 +33,7 @@ export enum QUERY_BUILDER_PURE_PATH {
 export enum QUERY_BUILDER_SUPPORTED_CALENDAR_AGGREGATION_FUNCTIONS {
   CALENDAR_ANNUALIZED = 'meta::pure::functions::date::calendar::annualized',
   CALENDAR_CME = ' meta::pure::functions::date::calendar::cme',
+
   CALENDAR_CW = 'meta::pure::functions::date::calendar::cw',
   CALENDAR_CW_FM = 'meta::pure::functions::date::calendar::cw_fm',
   CALENDAR_CY_MINUS2 = 'meta::pure::functions::date::calendar::CYMinus2',
@@ -114,6 +117,10 @@ export enum QUERY_BUILDER_SUPPORTED_FUNCTIONS {
   TDS_RESTRICT = 'meta::pure::tds::restrict',
   TDS_FUNC = 'meta::pure::tds::func',
 
+  // Relation
+  RELATION_PROJECT = 'meta::pure::functions::relation::project',
+  RELATION_LIMIT = 'meta::pure::functions::relation::limit',
+
   // filter
   CONTAINS = 'meta::pure::functions::string::contains',
   ENDS_WITH = 'meta::pure::functions::string::endsWith',

package/src/graph-manager/protocol/pure/QueryBuilder_PureProtocolProcessorPlugin.ts

@@ -146,10 +146,10 @@ export class QueryBuilder_PureProtocolProcessorPlugin extends PureProtocolProces
             processingContext,
           );
         } else if (
-          matchFunctionName(
-            functionName,
+          matchFunctionName(functionName, [
             QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_PROJECT,
-          )
+            QUERY_BUILDER_SUPPORTED_FUNCTIONS.RELATION_PROJECT,
+          ])
         ) {
           return V1_buildProjectFunctionExpression(
             functionName,

package/src/graph-manager/protocol/pure/v1/V1_QueryValueSpecificationBuilderHelper.ts

@@ -21,6 +21,7 @@ import {
   filterByType,
   guaranteeNonNullable,
   guaranteeType,
+  isNonNullable,
   returnUndefOnError,
 } from '@finos/legend-shared';
 import {
@@ -56,6 +57,11 @@ import {
   LambdaFunction,
   LambdaFunctionInstanceValue,
   PackageableElementExplicitReference,
+  V1_ClassInstance,
+  V1_ColSpecArray,
+  ColSpecArrayInstance,
+  ColSpecArray,
+  ColSpec,
 } from '@finos/legend-graph';
 import {
   QUERY_BUILDER_PURE_PATH,
@@ -574,6 +580,110 @@ export const V1_buildFilterFunctionExpression = (
   return expression;
 };
 
+export const V1_buildTypedProjectFunctionExpression = (
+  functionName: string,
+  parameters: V1_ValueSpecification[],
+  openVariables: string[],
+  compileContext: V1_GraphBuilderContext,
+  processingContext: V1_ProcessingContext,
+): SimpleFunctionExpression => {
+  assertTrue(
+    parameters.length === 2,
+    `Can't build relation project() expression: project() expects 2 arguments`,
+  );
+
+  let topLevelLambdaParameters: V1_Variable[] = [];
+  const precedingExperession = (
+    parameters[0] as V1_ValueSpecification
+  ).accept_ValueSpecificationVisitor(
+    new V1_ValueSpecificationBuilder(
+      compileContext,
+      processingContext,
+      openVariables,
+    ),
+  );
+  assertNonNullable(
+    precedingExperession.genericType,
+    `Can't build relation project() expression: preceding expression return type is missing`,
+  );
+
+  const classInstance = parameters[1];
+  assertType(
+    classInstance,
+    V1_ClassInstance,
+    `Can't build relation project() expression: project() expects argument #1 to be a ClassInstance`,
+  );
+  const specArray = guaranteeType(
+    classInstance.value,
+    V1_ColSpecArray,
+    `Can't build relation project() expression: project() expects argument #1 to hold spec array instances value`,
+  );
+
+  topLevelLambdaParameters = specArray.colSpecs
+    .map((e) => e.function1)
+    .filter(isNonNullable)
+    .filter(filterByType(V1_Lambda))
+    .map((lambda) => lambda.parameters)
+    .flat();
+
+  const variables = new Set<string>();
+  // Make sure top-level lambdas have their lambda parameter types set properly
+  topLevelLambdaParameters.forEach((variable) => {
+    if (!variables.has(variable.name) && !variable.class) {
+      const variableExpression = new VariableExpression(
+        variable.name,
+        precedingExperession.multiplicity,
+      );
+      variableExpression.genericType = precedingExperession.genericType;
+      processingContext.addInferredVariables(variable.name, variableExpression);
+    }
+  });
+  const processedExpression = new ColSpecArrayInstance(Multiplicity.ONE);
+  const processedColSpecArray = new ColSpecArray();
+  processedExpression.values = [processedColSpecArray];
+
+  processedColSpecArray.colSpecs = specArray.colSpecs.map((colSpec) => {
+    const pColSpec = new ColSpec();
+    let lambda: ValueSpecification;
+    const _funct = guaranteeType(
+      colSpec.function1,
+      V1_ValueSpecification,
+      `Can't build relation col spec() expression: expects function1 to be a lambda`,
+    );
+    try {
+      lambda = buildProjectionColumnLambda(
+        _funct,
+        openVariables,
+        compileContext,
+        processingContext,
+      );
+    } catch {
+      lambda = new INTERNAL__UnknownValueSpecification(
+        V1_serializeValueSpecification(
+          _funct,
+          compileContext.extensions.plugins,
+        ),
+      );
+    }
+    pColSpec.function1 = lambda;
+    pColSpec.name = colSpec.name;
+    return pColSpec;
+  });
+
+  const expression = V1_buildBaseSimpleFunctionExpression(
+    [precedingExperession, processedExpression],
+    functionName,
+    compileContext,
+  );
+  expression.genericType = GenericTypeExplicitReference.create(
+    new GenericType(
+      compileContext.resolveType(QUERY_BUILDER_PURE_PATH.RELATION).value,
+    ),
+  );
+
+  return expression;
+};
+
 export const V1_buildProjectFunctionExpression = (
   functionName: string,
   parameters: V1_ValueSpecification[],
@@ -581,8 +691,19 @@ export const V1_buildProjectFunctionExpression = (
   compileContext: V1_GraphBuilderContext,
   processingContext: V1_ProcessingContext,
 ): SimpleFunctionExpression => {
+  if (parameters.length === 2) {
+    return V1_buildTypedProjectFunctionExpression(
+      functionName,
+      parameters,
+      openVariables,
+      compileContext,
+      processingContext,
+    );
+  }
+
+  const length = parameters.length;
   assertTrue(
-    parameters.length === 3,
+    length === 3 || length === 2,
     `Can't build project() expression: project() expects 2 arguments`,
   );
 

package/src/index.ts

@@ -93,4 +93,4 @@ export * from './stores/QueryBuilder_LegendApplicationPlugin_Extension.js';
 
 export * from './stores/data-access/DataAccessState.js';
 export * from './components/data-access/DataAccessOverview.js';
-export * from './stores/workflow/QueryBuilderWorkFlowState.js';
+export * from './stores/query-workflow/QueryBuilderWorkFlowState.js';

package/src/stores/QueryBuilderResultState.ts

@@ -312,6 +312,7 @@ export class QueryBuilderResultState {
     if (this.queryBuilderState.isQuerySupported) {
       const lambdaFunction = buildLambdaFunction(this.queryBuilderState, {
         isBuildingExecutionQuery: true,
+        useTypedRelationFunctions: this.queryBuilderState.isFetchStructureTyped,
         ...executionOptions,
       });
       query = buildRawLambdaFromLambdaFunction(

package/src/stores/QueryBuilderState.ts

@@ -109,7 +109,7 @@ import {
 import type { QueryBuilderConfig } from '../graph-manager/QueryBuilderConfig.js';
 import { QUERY_BUILDER_EVENT } from '../__lib__/QueryBuilderEvent.js';
 import { QueryBuilderChangeHistoryState } from './QueryBuilderChangeHistoryState.js';
-import { type QueryBuilderWorkflowState } from './workflow/QueryBuilderWorkFlowState.js';
+import { type QueryBuilderWorkflowState } from './query-workflow/QueryBuilderWorkFlowState.js';
 
 export interface QuerySDLC {}
 
@@ -157,6 +157,8 @@ export abstract class QueryBuilderState implements CommandRegistrar {
   isQueryChatOpened = false;
   isLocalModeEnabled = false;
 
+  lambdaWriteMode = QUERY_BUILDER_LAMBDA_WRITER_MODE.STANDARD;
+
   class?: Class | undefined;
   getAllFunction: QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS =
     QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL;
@@ -204,6 +206,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
       isQueryChatOpened: observable,
       isLocalModeEnabled: observable,
       getAllFunction: observable,
+      lambdaWriteMode: observable,
 
       sideBarClassName: computed,
       isQuerySupported: computed,
@@ -218,6 +221,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
       setIsQueryChatOpened: action,
       setIsLocalModeEnabled: action,
       setGetAllFunction: action,
+      setLambdaWriteMode: action,
 
       resetQueryResult: action,
       resetQueryContent: action,
@@ -300,6 +304,17 @@ export abstract class QueryBuilderState implements CommandRegistrar {
     return this.allVariables.map((e) => e.name);
   }
 
+  get isFetchStructureTyped(): boolean {
+    return (
+      this.lambdaWriteMode ===
+      QUERY_BUILDER_LAMBDA_WRITER_MODE.TYPED_FETCH_STRUCTURE
+    );
+  }
+
+  setLambdaWriteMode(val: QUERY_BUILDER_LAMBDA_WRITER_MODE): void {
+    this.lambdaWriteMode = val;
+  }
+
   getQueryExecutionContext(): QueryExecutionContext {
     const queryExeContext = new QueryExplicitExecutionContext();
     const runtimeValue = guaranteeType(
@@ -538,6 +553,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
     return buildRawLambdaFromLambdaFunction(
       buildLambdaFunction(this, {
         keepSourceInformation: Boolean(options?.keepSourceInformation),
+        useTypedRelationFunctions: this.isFetchStructureTyped,
       }),
       this.graphManagerState,
     );

package/src/stores/QueryBuilderStateBuilder.ts

@@ -26,7 +26,7 @@ import {
 } from '@finos/legend-shared';
 import type { QueryBuilderState } from './QueryBuilderState.js';
 import {
-  type AbstractPropertyExpression,
+  AbstractPropertyExpression,
   type EnumValueInstanceValue,
   type FunctionExpression,
   type GraphFetchTreeInstanceValue,
@@ -36,7 +36,8 @@ import {
   type INTERNAL__PropagatedValue,
   type ValueSpecification,
   type CollectionInstanceValue,
-  type LambdaFunctionInstanceValue,
+  LambdaFunctionInstanceValue,
+  type ColSpecArrayInstance,
   InstanceValue,
   INTERNAL__UnknownValueSpecification,
   matchFunctionName,
@@ -481,6 +482,7 @@ export class QueryBuilderValueSpecificationProcessor
     ) {
       processTDSProjectionDerivationExpression(
         valueSpecification,
+        undefined,
         this.parentExpression,
         this.queryBuilderState,
       );
@@ -637,10 +639,10 @@ export class QueryBuilderValueSpecificationProcessor
       );
       return;
     } else if (
-      matchFunctionName(
-        functionName,
+      matchFunctionName(functionName, [
         QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_PROJECT,
-      )
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.RELATION_PROJECT,
+      ])
     ) {
       processTDSProjectExpression(
         valueSpecification,
@@ -835,6 +837,7 @@ export class QueryBuilderValueSpecificationProcessor
     if (
       matchFunctionName(this.parentExpression.functionName, [
         QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_PROJECT,
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.RELATION_PROJECT,
         QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_GROUP_BY,
         QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_AGG,
         ...Object.values(
@@ -844,6 +847,7 @@ export class QueryBuilderValueSpecificationProcessor
     ) {
       processTDSProjectionColumnPropertyExpression(
         valueSpecification,
+        undefined,
         this.queryBuilderState,
       );
       return;
@@ -903,6 +907,62 @@ export class QueryBuilderValueSpecificationProcessor
   ): void {
     throw new UnsupportedOperationError();
   }
+
+  visit_ColSpecArrayInstance(valueSpecification: ColSpecArrayInstance): void {
+    assertNonNullable(
+      this.parentExpression,
+      `Can't process col spec aray instance: parent expression cannot be retrieved`,
+    );
+
+    if (
+      matchFunctionName(this.parentExpression.functionName, [
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.RELATION_PROJECT,
+      ])
+    ) {
+      const spec = valueSpecification.values;
+      assertTrue(
+        spec.length === 1,
+        `Can't process col spec array instance: value expected to be of size 1`,
+      );
+      guaranteeNonNullable(spec[0]).colSpecs.forEach((col) => {
+        const _function1 = guaranteeType(
+          col.function1,
+          LambdaFunctionInstanceValue,
+          `Can't process col spec: function1 not a lambda function instance value`,
+        );
+        assertTrue(_function1.values.length === 1);
+        const lambdaVal = guaranteeNonNullable(_function1.values[0]);
+        assertTrue(lambdaVal.expressionSequence.length === 1);
+        const expression = guaranteeNonNullable(
+          lambdaVal.expressionSequence[0],
+        );
+
+        if (expression instanceof AbstractPropertyExpression) {
+          processTDSProjectionColumnPropertyExpression(
+            expression,
+            col.name,
+            this.queryBuilderState,
+          );
+        } else if (expression instanceof INTERNAL__UnknownValueSpecification) {
+          assertNonNullable(
+            this.parentExpression,
+            `Can't process unknown value: parent expression cannot be retrieved`,
+          );
+          processTDSProjectionDerivationExpression(
+            expression,
+            col.name,
+            this.parentExpression,
+            this.queryBuilderState,
+          );
+        }
+      });
+
+      return;
+    }
+    throw new UnsupportedOperationError(
+      `Can't process col spec array expression with parent expression of function ${this.parentExpression.functionName}()`,
+    );
+  }
 }
 
 export const processParameters = (

package/src/stores/QueryBuilderValueSpecificationBuilderHelper.ts

@@ -205,4 +205,9 @@ export type LambdaFunctionBuilderOption = {
    * limit for the query results if it exists so the exported results contain all the data
    */
   isExportingResult?: boolean | undefined;
+  /**
+   * Set this flag to `true` when you want to write to typed TDS function using the `Relation`
+   * typed in engine. This is still an experimental feature, hence we should only enable this flag when user wants to enable this directly.
+   */
+  useTypedRelationFunctions?: boolean | undefined;
 };

package/src/stores/__test-utils__/QueryBuilderStateTestUtils.ts

@@ -41,7 +41,7 @@ import {
   INTERNAL__BasicQueryBuilderState,
   type QueryBuilderState,
 } from '../QueryBuilderState.js';
-import { QueryBuilderAdvancedWorkflowState } from '../workflow/QueryBuilderWorkFlowState.js';
+import { QueryBuilderAdvancedWorkflowState } from '../query-workflow/QueryBuilderWorkFlowState.js';
 
 export class TEST__LegendApplicationPluginManager
   extends LegendApplicationPluginManager<LegendApplicationPlugin>

package/src/stores/fetch-structure/QueryBuilderFetchStructureImplementationState.ts

@@ -58,6 +58,7 @@ export abstract class QueryBuilderFetchStructureImplementationState
   abstract get usedExplorerTreePropertyNodeIDs(): string[];
   abstract get fetchStructureValidationIssues(): string[];
   abstract get allValidationIssues(): string[];
+  abstract get fetchLabel(): string;
 
   abstract onClassChange(_class: Class | undefined): void;
   abstract revealCompilationError(compilationError: CompilationError): boolean;

package/src/stores/fetch-structure/QueryBuilderFetchStructureState.ts

@@ -29,6 +29,21 @@ import {
   type QueryBuilderFetchStructureImplementationState,
 } from './QueryBuilderFetchStructureImplementationState.js';
 
+export const onChangeFetchStructureImplementation =
+  (
+    implementationType: FETCH_STRUCTURE_IMPLEMENTATION,
+    fetchStructureState: QueryBuilderFetchStructureState,
+  ): (() => void) =>
+  (): void => {
+    if (fetchStructureState.implementation.type !== implementationType) {
+      fetchStructureState.implementation.checkBeforeChangingImplementation(
+        () => {
+          fetchStructureState.changeImplementation(implementationType);
+        },
+      );
+    }
+  };
+
 export class QueryBuilderFetchStructureState {
   readonly queryBuilderState: QueryBuilderState;
   implementation: QueryBuilderFetchStructureImplementationState;

package/src/stores/fetch-structure/graph-fetch/QueryBuilderGraphFetchTreeState.ts

@@ -292,6 +292,7 @@ export class QueryBuilderGraphFetchTreeState
       setSerializationState: action,
       setChecked: action,
       initialize: action,
+      checkBeforeChangingImplementation: action,
     });
 
     // try to initialize the graph-fetch tree data using the setup class
@@ -304,6 +305,10 @@ export class QueryBuilderGraphFetchTreeState
     return FETCH_STRUCTURE_IMPLEMENTATION.GRAPH_FETCH;
   }
 
+  override get fetchLabel(): string {
+    return 'Class Properties';
+  }
+
   get usedExplorerTreePropertyNodeIDs(): string[] {
     if (!this.treeData) {
       return [];

package/src/stores/fetch-structure/tds/QueryBuilderTDSState.ts

@@ -154,6 +154,7 @@ export class QueryBuilderTDSState
       initializeWithQuery: action,
       setShowPostFilterPanel: action,
       setShowWindowFuncPanel: action,
+      checkBeforeChangingImplementation: action,
       convertDerivationProjectionObjects: flow,
       fetchDerivedReturnTypes: flow,
     });
@@ -194,6 +195,10 @@ export class QueryBuilderTDSState
     );
   }
 
+  override get fetchLabel(): string {
+    return 'Columns';
+  }
+
   override get TEMPORARY__showPostFetchStructurePanel(): boolean {
     return (
       this.queryBuilderState.filterState.showPanel ||