@finos/legend-application-query 5.2.2 → 5.2.3

package/src/stores/fetch-structure/projection/QueryBuilderProjectionState.ts

@@ -0,0 +1,390 @@
+/**
+ * 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 {
+  action,
+  flowResult,
+  makeObservable,
+  observable,
+  flow,
+  computed,
+} from 'mobx';
+import {
+  type GeneratorFn,
+  LogEvent,
+  assertErrorThrown,
+  changeEntry,
+  guaranteeType,
+  deleteEntry,
+  addUniqueEntry,
+  guaranteeNonNullable,
+  findLast,
+  filterByType,
+} from '@finos/legend-shared';
+import type { QueryBuilderState } from '../../QueryBuilderState.js';
+import {
+  type CompilationError,
+  GRAPH_MANAGER_EVENT,
+  extractSourceInformationCoordinates,
+  LAMBDA_PIPE,
+  RawLambda,
+  isStubbed_RawLambda,
+} from '@finos/legend-graph';
+import {
+  DEFAULT_LAMBDA_VARIABLE_NAME,
+  QUERY_BUILDER_SOURCE_ID_LABEL,
+} from '../../../QueryBuilder_Const.js';
+import { QueryBuilderAggregationState } from './aggregation/QueryBuilderAggregationState.js';
+import { buildGenericLambdaFunctionInstanceValue } from '../../QueryBuilderValueSpecificationHelper.js';
+import { QueryBuilderFetchStructureImplementationState } from '../QueryBuilderFetchStructureImplementationState.js';
+import { QueryResultSetModifierState } from './QueryResultSetModifierState.js';
+import { QueryBuilderPostFilterState } from './post-filter/QueryBuilderPostFilterState.js';
+import type { QueryBuilderPostFilterOperator } from './post-filter/QueryBuilderPostFilterOperator.js';
+import { getQueryBuilderCorePostFilterOperators } from './post-filter/QueryBuilderPostFilterOperatorLoader.js';
+import type { QueryBuilderAggregateOperator } from './aggregation/QueryBuilderAggregateOperator.js';
+import { getQueryBuilderCoreAggregrationOperators } from './aggregation/QueryBuilderAggregateOperatorLoader.js';
+import {
+  QueryBuilderDerivationProjectionColumnState,
+  type QueryBuilderProjectionColumnState,
+  type QueryBuilderSimpleProjectionColumnState,
+} from './QueryBuilderProjectionColumnState.js';
+import type { QueryBuilderFetchStructureState } from '../QueryBuilderFetchStructureState.js';
+
+export class QueryBuilderProjectionState extends QueryBuilderFetchStructureImplementationState {
+  columns: QueryBuilderProjectionColumnState[] = [];
+  aggregationState: QueryBuilderAggregationState;
+  postFilterState: QueryBuilderPostFilterState;
+  resultSetModifierState: QueryResultSetModifierState;
+  isConvertDerivationProjectionObjects = false;
+  showPostFilterPanel = false;
+
+  postFilterOperators: QueryBuilderPostFilterOperator[] =
+    getQueryBuilderCorePostFilterOperators();
+  aggregationOperators: QueryBuilderAggregateOperator[] =
+    getQueryBuilderCoreAggregrationOperators();
+
+  constructor(
+    queryBuilderState: QueryBuilderState,
+    fetchStructureState: QueryBuilderFetchStructureState,
+  ) {
+    super(queryBuilderState, fetchStructureState);
+
+    makeObservable(this, {
+      columns: observable,
+      aggregationState: observable,
+      postFilterState: observable,
+      resultSetModifierState: observable,
+      isConvertDerivationProjectionObjects: observable,
+      showPostFilterPanel: observable,
+      derivations: computed,
+      hasParserError: computed,
+      validationIssues: computed,
+      addColumn: action,
+      moveColumn: action,
+      replaceColumn: action,
+      setShowPostFilterPanel: action,
+      convertDerivationProjectionObjects: flow,
+    });
+
+    this.resultSetModifierState = new QueryResultSetModifierState(this);
+    this.postFilterState = new QueryBuilderPostFilterState(
+      this,
+      this.postFilterOperators,
+    );
+    this.aggregationState = new QueryBuilderAggregationState(
+      this,
+      this.aggregationOperators,
+    );
+  }
+
+  get derivations(): QueryBuilderDerivationProjectionColumnState[] {
+    return this.columns.filter(
+      filterByType(QueryBuilderDerivationProjectionColumnState),
+    );
+  }
+
+  get hasParserError(): boolean {
+    return this.derivations.some(
+      (derivation) => derivation.derivationLambdaEditorState.parserError,
+    );
+  }
+
+  get validationIssues(): string[] | undefined {
+    const hasDuplicatedProjectionColumns = this.columns.some(
+      (column) =>
+        this.columns.filter((c) => c.columnName === column.columnName).length >
+        1,
+    );
+    if (hasDuplicatedProjectionColumns) {
+      return ['Query has duplicated projection columns'];
+    }
+    const hasNoProjectionColumns = this.columns.length === 0;
+    if (hasNoProjectionColumns) {
+      return ['Query has no projection columns'];
+    }
+    return undefined;
+  }
+
+  setShowPostFilterPanel(val: boolean): void {
+    this.showPostFilterPanel = val;
+  }
+
+  *convertDerivationProjectionObjects(): GeneratorFn<void> {
+    const lambdas = new Map<string, RawLambda>();
+    const derivationProjectionColumnStateMap = new Map<
+      string,
+      QueryBuilderDerivationProjectionColumnState
+    >();
+    this.derivations.forEach((derivationProjectionColumnState) => {
+      if (!isStubbed_RawLambda(derivationProjectionColumnState.lambda)) {
+        lambdas.set(
+          derivationProjectionColumnState.derivationLambdaEditorState.lambdaId,
+          derivationProjectionColumnState.lambda,
+        );
+        derivationProjectionColumnStateMap.set(
+          derivationProjectionColumnState.derivationLambdaEditorState.lambdaId,
+          derivationProjectionColumnState,
+        );
+      }
+    });
+    if (lambdas.size) {
+      this.isConvertDerivationProjectionObjects = true;
+      try {
+        const isolatedLambdas =
+          (yield this.queryBuilderState.graphManagerState.graphManager.lambdasToPureCode(
+            lambdas,
+          )) as Map<string, string>;
+        isolatedLambdas.forEach((grammarText, key) => {
+          const derivationProjectionColumnState =
+            derivationProjectionColumnStateMap.get(key);
+          derivationProjectionColumnState?.derivationLambdaEditorState.setLambdaString(
+            derivationProjectionColumnState.derivationLambdaEditorState.extractLambdaString(
+              grammarText,
+            ),
+          );
+        });
+      } catch (error) {
+        assertErrorThrown(error);
+        this.queryBuilderState.applicationStore.log.error(
+          LogEvent.create(GRAPH_MANAGER_EVENT.PARSING_FAILURE),
+          error,
+        );
+      } finally {
+        this.isConvertDerivationProjectionObjects = false;
+      }
+    }
+  }
+
+  transformSimpleProjectionToDerivation(
+    simpleProjectionColumnState: QueryBuilderSimpleProjectionColumnState,
+  ): void {
+    // setup new derivation column state
+    const columnColumnLambda = buildGenericLambdaFunctionInstanceValue(
+      simpleProjectionColumnState.lambdaParameterName,
+      [simpleProjectionColumnState.propertyExpressionState.propertyExpression],
+      this.queryBuilderState.graphManagerState.graph,
+    );
+    const derivationColumnState =
+      new QueryBuilderDerivationProjectionColumnState(
+        this,
+        guaranteeType(
+          this.queryBuilderState.graphManagerState.graphManager.buildRawValueSpecification(
+            columnColumnLambda,
+            this.queryBuilderState.graphManagerState.graph,
+          ),
+          RawLambda,
+        ),
+      );
+    derivationColumnState.setColumnName(simpleProjectionColumnState.columnName);
+
+    this.replaceColumn(simpleProjectionColumnState, derivationColumnState);
+
+    // convert to grammar for display
+    flowResult(
+      derivationColumnState.derivationLambdaEditorState.convertLambdaObjectToGrammarString(
+        false,
+      ),
+    ).catch(this.queryBuilderState.applicationStore.alertUnhandledError);
+  }
+
+  replaceColumn(
+    oldVal: QueryBuilderProjectionColumnState,
+    newVal: QueryBuilderProjectionColumnState,
+  ): void {
+    // reassociation with column aggregation state if applicable
+    const corresspondingAggregateColumnState =
+      this.aggregationState.columns.find(
+        (aggregateColState) =>
+          aggregateColState.projectionColumnState === oldVal,
+      );
+    if (corresspondingAggregateColumnState) {
+      corresspondingAggregateColumnState.setColumnState(newVal);
+    }
+
+    // reassociation with column sorting state if applicable
+    const corresspondingSortColumnState =
+      this.resultSetModifierState.sortColumns.find(
+        (sortColState) => sortColState.columnState === oldVal,
+      );
+    if (corresspondingSortColumnState) {
+      corresspondingSortColumnState.setColumnState(newVal);
+    }
+
+    changeEntry(this.columns, oldVal, newVal);
+  }
+
+  removeColumn(val: QueryBuilderProjectionColumnState): void {
+    deleteEntry(this.columns, val);
+
+    // remove aggregation that goes with the projection
+    const existingAggregateColumnState = this.aggregationState.columns.find(
+      (column) => column.projectionColumnState === val,
+    );
+    if (existingAggregateColumnState) {
+      this.aggregationState.removeColumn(existingAggregateColumnState);
+    }
+
+    this.resultSetModifierState.updateSortColumns();
+  }
+
+  addColumn(
+    val: QueryBuilderProjectionColumnState,
+    options?: {
+      /**
+       * Often time, we would want to enforce doing a sort when adding new column
+       * to ensure aggregate columns stay at the bottom of the list of projections
+       * But sometimes, we can opt in to use this flag to disable this sorting behavior,
+       * such as when we build/process.
+       */
+      skipSorting?: boolean | undefined;
+    },
+  ): void {
+    addUniqueEntry(this.columns, val);
+
+    if (!options?.skipSorting) {
+      // sort columns: aggregate columns go last
+      this.columns = this.columns
+        .slice()
+        .sort(
+          (colA, colB) =>
+            (this.aggregationState.columns.find(
+              (column) => column.projectionColumnState === colA,
+            )
+              ? 1
+              : 0) -
+            (this.aggregationState.columns.find(
+              (column) => column.projectionColumnState === colB,
+            )
+              ? 1
+              : 0),
+        );
+    }
+  }
+
+  moveColumn(sourceIndex: number, targetIndex: number): void {
+    if (
+      sourceIndex < 0 ||
+      sourceIndex >= this.columns.length ||
+      targetIndex < 0 ||
+      targetIndex >= this.columns.length
+    ) {
+      return;
+    }
+
+    const sourceColumn = guaranteeNonNullable(this.columns[sourceIndex]);
+
+    // find last non aggregate column index for computation
+    const lastNonAggregateColumn = findLast(
+      this.columns,
+      (projectionCol) =>
+        !this.aggregationState.columns.find(
+          (column) => column.projectionColumnState === projectionCol,
+        ),
+    );
+
+    const lastNonAggregateColumnIndex = lastNonAggregateColumn
+      ? this.columns.lastIndexOf(lastNonAggregateColumn)
+      : 0;
+    if (
+      this.aggregationState.columns.find(
+        (column) => column.projectionColumnState === sourceColumn,
+      )
+    ) {
+      // if the column being moved is an aggregate column,
+      // it cannot be moved to before the first aggregate column
+      targetIndex = Math.max(
+        targetIndex,
+        Math.min(lastNonAggregateColumnIndex + 1, this.columns.length - 1),
+      );
+    } else {
+      // if the column being moved is not an aggregate column,
+      // it cannot be moved to after the last non-aggregate column
+      targetIndex = Math.min(targetIndex, lastNonAggregateColumnIndex);
+    }
+
+    // move
+    this.columns.splice(sourceIndex, 1);
+    this.columns.splice(targetIndex, 0, sourceColumn);
+  }
+
+  addNewBlankDerivation(): void {
+    const derivation = new QueryBuilderDerivationProjectionColumnState(
+      this,
+      this.queryBuilderState.graphManagerState.graphManager.createDefaultBasicRawLambda(
+        { addDummyParameter: true },
+      ),
+    );
+    this.addColumn(derivation);
+    derivation.derivationLambdaEditorState.setLambdaString(
+      `${DEFAULT_LAMBDA_VARIABLE_NAME}${LAMBDA_PIPE}''`,
+    );
+  }
+
+  revealCompilationError(compilationError: CompilationError): boolean {
+    const elementCoordinates = extractSourceInformationCoordinates(
+      compilationError.sourceInformation,
+    );
+    if (
+      elementCoordinates &&
+      elementCoordinates.length === 3 &&
+      elementCoordinates[0] === QUERY_BUILDER_SOURCE_ID_LABEL.QUERY_BUILDER &&
+      elementCoordinates[1] === QUERY_BUILDER_SOURCE_ID_LABEL.PROJECTION
+    ) {
+      const derivationProjectionState = this.columns.find(
+        (projectionColumnState) =>
+          projectionColumnState.uuid === elementCoordinates[2],
+      );
+      if (
+        derivationProjectionState instanceof
+        QueryBuilderDerivationProjectionColumnState
+      ) {
+        derivationProjectionState.derivationLambdaEditorState.setCompilationError(
+          compilationError,
+        );
+        return true;
+      }
+    }
+    return false;
+  }
+
+  clearCompilationError(): void {
+    this.derivations.forEach((derivationProjectionColumnState) =>
+      derivationProjectionColumnState.derivationLambdaEditorState.setCompilationError(
+        undefined,
+      ),
+    );
+  }
+}

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

@@ -0,0 +1,170 @@
+/**
+ * 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 LambdaFunction,
+  CollectionInstanceValue,
+  extractElementNameFromPath,
+  GenericType,
+  GenericTypeExplicitReference,
+  matchFunctionName,
+  Multiplicity,
+  PrimitiveInstanceValue,
+  PRIMITIVE_TYPE,
+  SimpleFunctionExpression,
+  TYPICAL_MULTIPLICITY_TYPE,
+} from '@finos/legend-graph';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../QueryBuilder_Const.js';
+import {
+  COLUMN_SORT_TYPE,
+  type QueryResultSetModifierState,
+  type SortColumnState,
+} from './QueryResultSetModifierState.js';
+
+const buildSortExpression = (
+  sortColumnState: SortColumnState,
+): SimpleFunctionExpression => {
+  const multiplicityOne =
+    sortColumnState.columnState.projectionState.queryBuilderState.graphManagerState.graph.getTypicalMultiplicity(
+      TYPICAL_MULTIPLICITY_TYPE.ONE,
+    );
+  const sortColumnFunction = new SimpleFunctionExpression(
+    extractElementNameFromPath(
+      sortColumnState.sortType === COLUMN_SORT_TYPE.ASC
+        ? QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_ASC
+        : QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_DESC,
+    ),
+    multiplicityOne,
+  );
+  const sortColumnName = new PrimitiveInstanceValue(
+    GenericTypeExplicitReference.create(
+      new GenericType(
+        sortColumnState.columnState.projectionState.queryBuilderState.graphManagerState.graph.getPrimitiveType(
+          PRIMITIVE_TYPE.STRING,
+        ),
+      ),
+    ),
+    multiplicityOne,
+  );
+  sortColumnName.values = [sortColumnState.columnState.columnName];
+  sortColumnFunction.parametersValues[0] = sortColumnName;
+  return sortColumnFunction;
+};
+
+export const appendResultSetModifiers = (
+  resultModifiersState: QueryResultSetModifierState,
+  lambda: LambdaFunction,
+  options?:
+    | {
+        overridingLimit?: number | undefined;
+      }
+    | undefined,
+): LambdaFunction => {
+  const multiplicityOne =
+    resultModifiersState.projectionState.queryBuilderState.graphManagerState.graph.getTypicalMultiplicity(
+      TYPICAL_MULTIPLICITY_TYPE.ONE,
+    );
+  if (lambda.expressionSequence.length === 1) {
+    const func = lambda.expressionSequence[0];
+    if (func instanceof SimpleFunctionExpression) {
+      if (
+        matchFunctionName(
+          func.functionName,
+          QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_PROJECT,
+        ) ||
+        matchFunctionName(
+          func.functionName,
+          QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_GROUP_BY,
+        ) ||
+        matchFunctionName(
+          func.functionName,
+          QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_FILTER,
+        )
+      ) {
+        let currentExpression = func;
+
+        // build distinct()
+        if (resultModifiersState.distinct) {
+          const distinctFunction = new SimpleFunctionExpression(
+            extractElementNameFromPath(
+              QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_DISTINCT,
+            ),
+            multiplicityOne,
+          );
+          distinctFunction.parametersValues[0] = currentExpression;
+          currentExpression = distinctFunction;
+        }
+
+        // build sort()
+        if (resultModifiersState.sortColumns.length) {
+          const sortFunction = new SimpleFunctionExpression(
+            extractElementNameFromPath(
+              QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_SORT,
+            ),
+            multiplicityOne,
+          );
+          const multiplicity = new Multiplicity(
+            resultModifiersState.sortColumns.length,
+            resultModifiersState.sortColumns.length,
+          );
+          const collection = new CollectionInstanceValue(
+            multiplicity,
+            undefined,
+          );
+          collection.values =
+            resultModifiersState.sortColumns.map(buildSortExpression);
+          sortFunction.parametersValues[0] = currentExpression;
+          sortFunction.parametersValues[1] = collection;
+          currentExpression = sortFunction;
+        }
+
+        // build take()
+        if (resultModifiersState.limit || options?.overridingLimit) {
+          const limit = new PrimitiveInstanceValue(
+            GenericTypeExplicitReference.create(
+              new GenericType(
+                resultModifiersState.projectionState.queryBuilderState.graphManagerState.graph.getPrimitiveType(
+                  PRIMITIVE_TYPE.INTEGER,
+                ),
+              ),
+            ),
+            multiplicityOne,
+          );
+          limit.values = [
+            Math.min(
+              resultModifiersState.limit ?? Number.MAX_SAFE_INTEGER,
+              options?.overridingLimit ?? Number.MAX_SAFE_INTEGER,
+            ),
+          ];
+          const takeFunction = new SimpleFunctionExpression(
+            extractElementNameFromPath(
+              QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_TAKE,
+            ),
+            multiplicityOne,
+          );
+
+          takeFunction.parametersValues[0] = currentExpression;
+          takeFunction.parametersValues[1] = limit;
+          currentExpression = takeFunction;
+        }
+
+        lambda.expressionSequence[0] = currentExpression;
+        return lambda;
+      }
+    }
+  }
+  return lambda;
+};

package/src/stores/fetch-structure/projection/QueryResultSetModifierState.ts

@@ -0,0 +1,95 @@
+/**
+ * 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 { action, makeAutoObservable } from 'mobx';
+import type { QueryBuilderProjectionState } from './QueryBuilderProjectionState.js';
+import type { QueryBuilderProjectionColumnState } from './QueryBuilderProjectionColumnState.js';
+import { addUniqueEntry, deleteEntry } from '@finos/legend-shared';
+
+export enum COLUMN_SORT_TYPE {
+  ASC,
+  DESC,
+}
+
+export class SortColumnState {
+  columnState: QueryBuilderProjectionColumnState;
+  sortType = COLUMN_SORT_TYPE.ASC;
+
+  constructor(columnState: QueryBuilderProjectionColumnState) {
+    makeAutoObservable(this, {
+      setColumnState: action,
+      setSortType: action,
+    });
+
+    this.columnState = columnState;
+  }
+
+  setColumnState(val: QueryBuilderProjectionColumnState): void {
+    this.columnState = val;
+  }
+
+  setSortType(val: COLUMN_SORT_TYPE): void {
+    this.sortType = val;
+  }
+}
+
+export class QueryResultSetModifierState {
+  projectionState: QueryBuilderProjectionState;
+  showModal = false;
+  limit?: number | undefined;
+  distinct = false;
+  sortColumns: SortColumnState[] = [];
+
+  constructor(projectionState: QueryBuilderProjectionState) {
+    makeAutoObservable(this, {
+      projectionState: false,
+      setShowModal: action,
+      setLimit: action,
+      toggleDistinct: action,
+      deleteSortColumn: action,
+      addSortColumn: action,
+      updateSortColumns: action,
+    });
+
+    this.projectionState = projectionState;
+  }
+
+  setShowModal(val: boolean): void {
+    this.showModal = val;
+  }
+
+  setLimit(val: number | undefined): void {
+    this.limit = val === undefined || val <= 0 ? undefined : val;
+  }
+
+  toggleDistinct(): void {
+    this.distinct = !this.distinct;
+  }
+
+  deleteSortColumn(val: SortColumnState): void {
+    deleteEntry(this.sortColumns, val);
+  }
+
+  addSortColumn(val: SortColumnState): void {
+    addUniqueEntry(this.sortColumns, val);
+  }
+
+  updateSortColumns(): void {
+    this.sortColumns = this.sortColumns.filter((e) =>
+      this.projectionState.columns.includes(e.columnState),
+    );
+  }
+}