@finos/legend-query-builder 4.15.41 → 4.15.43

package/src/stores/data-cube/QueryBuilderDataCubeEngine.ts

@@ -25,7 +25,6 @@ import {
   V1_RawLambda,
   V1_serializeValueSpecification,
   type GraphManagerState,
-  type PureModel,
   type V1_ValueSpecification,
   type ParameterValue,
   LAMBDA_PIPE,
@@ -79,53 +78,7 @@ export class QueryBuilderDataCubeEngine extends DataCubeEngine {
     this.parameters = selectQuery.parameters;
   }
 
-  get sourceLabel(): string {
-    return `Query Builder Report`;
-  }
-
-  get graph(): PureModel {
-    return this.graphState.graph;
-  }
-
-  private getSourceFunctionExpression() {
-    let srcFuncExp = V1_deserializeValueSpecification(
-      this.graphState.graphManager.serializeRawValueSpecification(
-        this.selectInitialQuery,
-      ),
-      [],
-    );
-    // We could do a further check here to ensure the experssion is an applied funciton
-    // this is because data cube expects an expression to be able to built further upon the queery
-    if (
-      srcFuncExp instanceof V1_Lambda &&
-      srcFuncExp.body.length === 1 &&
-      srcFuncExp.body[0]
-    ) {
-      srcFuncExp = srcFuncExp.body[0];
-    }
-    return srcFuncExp;
-  }
-
-  async generateInitialQuery() {
-    const srcFuncExp = this.getSourceFunctionExpression();
-    const fromFuncExp = new V1_AppliedFunction();
-    fromFuncExp.function = _functionName(SUPPORTED_FUNCTIONS.FROM);
-    fromFuncExp.parameters = [srcFuncExp];
-    if (this.mappingPath) {
-      fromFuncExp.parameters.push(_elementPtr(this.mappingPath));
-    }
-    if (this.runtimePath) {
-      fromFuncExp.parameters.push(_elementPtr(this.runtimePath));
-    }
-    const columns = (await this.getRelationType(this.selectInitialQuery))
-      .columns;
-    const query = new DataCubeQuery();
-    query.query = `~[${columns.map((e) => `'${e.name}'`)}]->select()`;
-
-    return query;
-  }
-
-  async processQuerySource(value: PlainObject) {
+  override async processQuerySource(value: PlainObject) {
     // TODO: this is an abnormal usage of this method, this is the place
     // where we can enforce which source this engine supports, instead
     // of hardcoding the logic like this.
@@ -140,17 +93,30 @@ export class QueryBuilderDataCubeEngine extends DataCubeEngine {
     return source;
   }
 
-  private buildRawLambdaFromValueSpec(query: V1_Lambda): RawLambda {
-    const json = guaranteeType(
-      V1_deserializeRawValueSpecification(
-        V1_serializeValueSpecification(query, []),
+  override async parseValueSpecification(
+    code: string,
+    returnSourceInformation?: boolean,
+  ) {
+    return V1_deserializeValueSpecification(
+      await this.graphState.graphManager.pureCodeToValueSpecification(
+        code,
+        returnSourceInformation,
       ),
-      V1_RawLambda,
+      [],
+    );
+  }
+
+  override async getValueSpecificationCode(
+    value: V1_ValueSpecification,
+    pretty?: boolean | undefined,
+  ) {
+    return this.graphState.graphManager.valueSpecificationToPureCode(
+      V1_serializeValueSpecification(value, []),
+      pretty,
     );
-    return new RawLambda(json.parameters, json.body);
   }
 
-  async getQueryTypeahead(
+  override async getQueryTypeahead(
     code: string,
     baseQuery: V1_Lambda,
     source: DataCubeSource,
@@ -166,42 +132,17 @@ export class QueryBuilderDataCubeEngine extends DataCubeEngine {
     );
     const result = await this.graphState.graphManager.getCodeComplete(
       finalCode,
-      this.graph,
+      this.graphState.graph,
       offset,
     );
     return result.completions as CompletionItem[];
   }
 
-  override async parseValueSpecification(
-    code: string,
-    returnSourceInformation?: boolean,
-  ) {
-    return V1_deserializeValueSpecification(
-      await this.graphState.graphManager.pureCodeToValueSpecification(
-        code,
-        returnSourceInformation,
-      ),
-      [],
-    );
-  }
-
-  override async getValueSpecificationCode(
-    value: V1_ValueSpecification,
-    pretty?: boolean | undefined,
+  override async getQueryRelationReturnType(
+    query: V1_Lambda,
+    source: DataCubeSource,
   ) {
-    return this.graphState.graphManager.valueSpecificationToPureCode(
-      V1_serializeValueSpecification(value, []),
-      pretty,
-    );
-  }
-
-  async getRelationType(query: RawLambda) {
-    const relationType =
-      await this.graphState.graphManager.getLambdaRelationType(
-        query,
-        this.graph,
-      );
-    return relationType;
+    return this.getRelationType(this.buildRawLambdaFromValueSpec(query));
   }
 
   override async getQueryCodeRelationReturnType(
@@ -227,7 +168,7 @@ export class QueryBuilderDataCubeEngine extends DataCubeEngine {
         lambda,
         undefined,
         undefined,
-        this.graph,
+        this.graphState.graph,
         {
           parameterValues: this.parameterValues ?? [],
         },
@@ -268,4 +209,63 @@ export class QueryBuilderDataCubeEngine extends DataCubeEngine {
     }
     return undefined;
   }
+
+  // ---------------------------------- UTILITIES ----------------------------------
+
+  private buildRawLambdaFromValueSpec(query: V1_Lambda): RawLambda {
+    const json = guaranteeType(
+      V1_deserializeRawValueSpecification(
+        V1_serializeValueSpecification(query, []),
+      ),
+      V1_RawLambda,
+    );
+    return new RawLambda(json.parameters, json.body);
+  }
+
+  private getSourceFunctionExpression() {
+    let srcFuncExp = V1_deserializeValueSpecification(
+      this.graphState.graphManager.serializeRawValueSpecification(
+        this.selectInitialQuery,
+      ),
+      [],
+    );
+    // We could do a further check here to ensure the experssion is an applied funciton
+    // this is because data cube expects an expression to be able to built further upon the queery
+    if (
+      srcFuncExp instanceof V1_Lambda &&
+      srcFuncExp.body.length === 1 &&
+      srcFuncExp.body[0]
+    ) {
+      srcFuncExp = srcFuncExp.body[0];
+    }
+    return srcFuncExp;
+  }
+
+  async generateInitialQuery() {
+    const srcFuncExp = this.getSourceFunctionExpression();
+    const fromFuncExp = new V1_AppliedFunction();
+    fromFuncExp.function = _functionName(SUPPORTED_FUNCTIONS.FROM);
+    fromFuncExp.parameters = [srcFuncExp];
+    if (this.mappingPath) {
+      fromFuncExp.parameters.push(_elementPtr(this.mappingPath));
+    }
+    if (this.runtimePath) {
+      fromFuncExp.parameters.push(_elementPtr(this.runtimePath));
+    }
+    const columns = (await this.getRelationType(this.selectInitialQuery))
+      .columns;
+    const query = new DataCubeQuery();
+    query.query = `~[${columns.map((e) => `'${e.name}'`)}]->select()`;
+
+    return query;
+  }
+
+  async getRelationType(query: RawLambda) {
+    const relationType =
+      await this.graphState.graphManager.getLambdaRelationType(
+        query,
+        this.graphState.graph,
+      );
+    return relationType;
+  }
 }

package/src/stores/fetch-structure/tds/projection/QueryBuilderProjectionStateBuilder.ts

@@ -29,6 +29,7 @@ import {
   VariableExpression,
   PrimitiveInstanceValue,
   LambdaFunctionInstanceValue,
+  ColSpecInstanceValue,
 } from '@finos/legend-graph';
 import {
   assertNonNullable,
@@ -603,7 +604,7 @@ export const processTDSSortDirectionExpression = (
   // check parameters
   assertTrue(
     expression.parametersValues.length === 1,
-    `Can't process ${functionName}() expression: ${functionName}() expects no argument`,
+    `Can't process ${functionName}() expression: ${functionName}() expects one argument`,
   );
 
   // build state
@@ -633,3 +634,65 @@ export const processTDSSortDirectionExpression = (
     }
   }
 };
+
+export const processRelationSortDirectionExpression = (
+  expression: SimpleFunctionExpression,
+  parentExpression: SimpleFunctionExpression | undefined,
+  queryBuilderState: QueryBuilderState,
+): void => {
+  const functionName = expression.functionName;
+
+  // check parent expression
+  assertTrue(
+    Boolean(
+      parentExpression &&
+        matchFunctionName(
+          parentExpression.functionName,
+          QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_SORT,
+        ),
+    ),
+    `Can't process ${functionName}() expression: only support ${functionName}() used within a sort() expression`,
+  );
+
+  // check parameters
+  assertTrue(
+    expression.parametersValues.length === 1,
+    `Can't process ${functionName}() expression: ${functionName}() expects one argument`,
+  );
+
+  // build state
+  if (
+    queryBuilderState.fetchStructureState.implementation instanceof
+    QueryBuilderTDSState
+  ) {
+    const projectionState =
+      queryBuilderState.fetchStructureState.implementation;
+    const value = guaranteeType(
+      expression.parametersValues[0],
+      ColSpecInstanceValue,
+    );
+    assertTrue(
+      value.values.length === 1,
+      `Can't process ${functionName}() expression: Col Spec Instance Value expects one value`,
+    );
+    const sortColumnName = guaranteeNonNullable(
+      value.values[0],
+      `Col Spec value expected in Col Spec Instance Value`,
+    ).name;
+    const queryBuilderProjectionColumnState = projectionState.tdsColumns.find(
+      (e) => e.columnName === sortColumnName,
+    );
+    if (queryBuilderProjectionColumnState) {
+      const sortColumnState = new SortColumnState(
+        queryBuilderProjectionColumnState,
+      );
+      sortColumnState.sortType = matchFunctionName(
+        functionName,
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.RELATION_ASC,
+      )
+        ? COLUMN_SORT_TYPE.ASC
+        : COLUMN_SORT_TYPE.DESC;
+      projectionState.resultSetModifierState.addSortColumn(sortColumnState);
+    }
+  }
+};

package/src/stores/fetch-structure/tds/projection/QueryBuilderProjectionValueSpecificationBuilder.ts

@@ -27,7 +27,6 @@ import {
   V1_serializeRawValueSpecification,
   V1_transformRawLambda,
   V1_GraphTransformerContextBuilder,
-  matchFunctionName,
   PrimitiveType,
   LambdaFunctionInstanceValue,
 } from '@finos/legend-graph';
@@ -42,10 +41,6 @@ import {
   QueryBuilderSimpleProjectionColumnState,
 } from './QueryBuilderProjectionColumnState.js';
 import type { QueryBuilderTDSState } from '../QueryBuilderTDSState.js';
-import {
-  type QueryResultSetModifierState,
-  type SortColumnState,
-} from '../QueryResultSetModifierState.js';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../graph/QueryBuilderMetaModelConst.js';
 import { buildGenericLambdaFunctionInstanceValue } from '../../../QueryBuilderValueSpecificationHelper.js';
 import {
@@ -54,139 +49,9 @@ import {
 } from '../../../QueryBuilderValueSpecificationBuilderHelper.js';
 import { appendOLAPGroupByState } from '../window/QueryBuilderWindowValueSpecificationBuilder.js';
 import { appendPostFilter } from '../post-filter/QueryBuilderPostFilterValueSpecificationBuilder.js';
-import { buildTDSSortTypeExpression } from '../QueryBuilderTDSHelper.js';
 import { buildRelationProjection } from './QueryBuilderRelationProjectValueSpecBuidler.js';
 import { QueryBuilderAggregateOperator_Wavg } from '../aggregation/operators/QueryBuilderAggregateOperator_Wavg.js';
-
-const buildSortExpression = (
-  sortColumnState: SortColumnState,
-): SimpleFunctionExpression =>
-  buildTDSSortTypeExpression(
-    sortColumnState.sortType,
-    sortColumnState.columnState.columnName,
-  );
-
-const appendResultSetModifier = (
-  resultModifierState: QueryResultSetModifierState,
-  lambdaFunction: LambdaFunction,
-  options?:
-    | {
-        overridingLimit?: number | undefined;
-        withDataOverflowCheck?: boolean | undefined;
-      }
-    | undefined,
-): LambdaFunction => {
-  if (lambdaFunction.expressionSequence.length === 1) {
-    const func = lambdaFunction.expressionSequence[0];
-    if (func instanceof SimpleFunctionExpression) {
-      if (
-        matchFunctionName(func.functionName, [
-          QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_PROJECT,
-          QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_GROUP_BY,
-          QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_FILTER,
-          QUERY_BUILDER_SUPPORTED_FUNCTIONS.OLAP_GROUPBY,
-        ])
-      ) {
-        let currentExpression = func;
-
-        // build distinct()
-        if (resultModifierState.distinct) {
-          const distinctFunction = new SimpleFunctionExpression(
-            extractElementNameFromPath(
-              QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_DISTINCT,
-            ),
-          );
-          distinctFunction.parametersValues[0] = currentExpression;
-          currentExpression = distinctFunction;
-        }
-
-        // build sort()
-        if (resultModifierState.sortColumns.length) {
-          const sortFunction = new SimpleFunctionExpression(
-            extractElementNameFromPath(
-              QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_SORT,
-            ),
-          );
-          const multiplicity =
-            resultModifierState.tdsState.queryBuilderState.graphManagerState.graph.getMultiplicity(
-              resultModifierState.sortColumns.length,
-              resultModifierState.sortColumns.length,
-            );
-          const collection = new CollectionInstanceValue(
-            multiplicity,
-            undefined,
-          );
-          collection.values =
-            resultModifierState.sortColumns.map(buildSortExpression);
-          sortFunction.parametersValues[0] = currentExpression;
-          sortFunction.parametersValues[1] = collection;
-          currentExpression = sortFunction;
-        }
-
-        // build take()
-        if (resultModifierState.limit || options?.overridingLimit) {
-          const limit = new PrimitiveInstanceValue(
-            GenericTypeExplicitReference.create(
-              new GenericType(PrimitiveType.INTEGER),
-            ),
-          );
-          limit.values = [
-            Math.min(
-              resultModifierState.limit
-                ? options?.withDataOverflowCheck
-                  ? resultModifierState.limit + 1
-                  : resultModifierState.limit
-                : Number.MAX_SAFE_INTEGER,
-              options?.overridingLimit
-                ? options.withDataOverflowCheck
-                  ? options.overridingLimit + 1
-                  : options.overridingLimit
-                : Number.MAX_SAFE_INTEGER,
-            ),
-          ];
-          const takeFunction = new SimpleFunctionExpression(
-            extractElementNameFromPath(
-              QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_TAKE,
-            ),
-          );
-          takeFunction.parametersValues[0] = currentExpression;
-          takeFunction.parametersValues[1] = limit;
-          currentExpression = takeFunction;
-        }
-        // build slice()
-        if (resultModifierState.slice) {
-          const sliceStart = resultModifierState.slice[0];
-          const sliceEnd = resultModifierState.slice[1];
-          const startVal = new PrimitiveInstanceValue(
-            GenericTypeExplicitReference.create(
-              new GenericType(PrimitiveType.INTEGER),
-            ),
-          );
-          const endVal = new PrimitiveInstanceValue(
-            GenericTypeExplicitReference.create(
-              new GenericType(PrimitiveType.INTEGER),
-            ),
-          );
-          startVal.values = [sliceStart];
-          endVal.values = [sliceEnd];
-          const sliceFunction = new SimpleFunctionExpression(
-            extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.SLICE),
-          );
-          sliceFunction.parametersValues = [
-            currentExpression,
-            startVal,
-            endVal,
-          ];
-          currentExpression = sliceFunction;
-        }
-
-        lambdaFunction.expressionSequence[0] = currentExpression;
-        return lambdaFunction;
-      }
-    }
-  }
-  return lambdaFunction;
-};
+import { appendResultSetModifier } from '../result-modifier/ResultModifierValueSpecificationBuilder.js';
 
 const buildProjectColFunc = (
   tdsState: QueryBuilderTDSState,
@@ -542,14 +407,19 @@ export const appendProjection = (
   appendPostFilter(tdsState.postFilterState, lambdaFunction);
 
   // build result set modifiers
-  appendResultSetModifier(tdsState.resultSetModifierState, lambdaFunction, {
-    overridingLimit:
-      options?.isBuildingExecutionQuery && !options.isExportingResult
-        ? queryBuilderState.resultState.previewLimit
-        : undefined,
-    withDataOverflowCheck:
-      options?.isBuildingExecutionQuery && !options.isExportingResult
-        ? options.withDataOverflowCheck
-        : undefined,
-  });
+  appendResultSetModifier(
+    tdsState.resultSetModifierState,
+    lambdaFunction,
+    tdsState.queryBuilderState.isFetchStructureTyped,
+    {
+      overridingLimit:
+        options?.isBuildingExecutionQuery && !options.isExportingResult
+          ? queryBuilderState.resultState.previewLimit
+          : undefined,
+      withDataOverflowCheck:
+        options?.isBuildingExecutionQuery && !options.isExportingResult
+          ? options.withDataOverflowCheck
+          : undefined,
+    },
+  );
 };