@finos/legend-application-query 5.0.0

package/src/stores/QueryBuilderOperatorsHelper.ts

@@ -0,0 +1,191 @@
+/**
+ * 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 PrimitiveType,
+  type Enumeration,
+  type Type,
+  type PureModel,
+  type ValueSpecification,
+  PRIMITIVE_TYPE,
+  extractElementNameFromPath,
+  matchFunctionName,
+  SimpleFunctionExpression,
+  TYPICAL_MULTIPLICITY_TYPE,
+  PrimitiveInstanceValue,
+  EnumValueInstanceValue,
+  VariableExpression,
+  AbstractPropertyExpression,
+} from '@finos/legend-graph';
+import {
+  addUniqueEntry,
+  guaranteeNonNullable,
+  guaranteeType,
+  UnsupportedOperationError,
+} from '@finos/legend-shared';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../QueryBuilder_Const.js';
+
+export enum QUERY_BUILDER_GROUP_OPERATION {
+  AND = 'and',
+  OR = 'or',
+}
+
+export const fromGroupOperation = (
+  operation: QUERY_BUILDER_GROUP_OPERATION,
+): string => {
+  switch (operation) {
+    case QUERY_BUILDER_GROUP_OPERATION.AND:
+      return QUERY_BUILDER_SUPPORTED_FUNCTIONS.AND;
+    case QUERY_BUILDER_GROUP_OPERATION.OR:
+      return QUERY_BUILDER_SUPPORTED_FUNCTIONS.OR;
+    default:
+      throw new UnsupportedOperationError(
+        `Can't derive function name from group operation '${operation}'`,
+      );
+  }
+};
+
+export const toGroupOperation = (
+  functionName: string,
+): QUERY_BUILDER_GROUP_OPERATION => {
+  if (matchFunctionName(functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.AND)) {
+    return QUERY_BUILDER_GROUP_OPERATION.AND;
+  } else if (
+    matchFunctionName(functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.OR)
+  ) {
+    return QUERY_BUILDER_GROUP_OPERATION.OR;
+  }
+  throw new UnsupportedOperationError(
+    `Can't derive group operation from function name '${functionName}'`,
+  );
+};
+
+export const getNonCollectionValueSpecificationType = (
+  valueSpecification: ValueSpecification,
+): Type | undefined => {
+  if (valueSpecification instanceof PrimitiveInstanceValue) {
+    return valueSpecification.genericType.value.rawType;
+  } else if (valueSpecification instanceof EnumValueInstanceValue) {
+    return guaranteeNonNullable(valueSpecification.values[0]).value._OWNER;
+  } else if (valueSpecification instanceof VariableExpression) {
+    return valueSpecification.genericType?.value.rawType;
+  } else if (valueSpecification instanceof SimpleFunctionExpression) {
+    return valueSpecification.genericType?.value.rawType;
+  }
+  return undefined;
+};
+
+export const getCollectionValueSpecificationType = (
+  graph: PureModel,
+  values: ValueSpecification[],
+): Type | undefined => {
+  if (values.every((val) => val instanceof PrimitiveInstanceValue)) {
+    const valuePrimitiveTypes: (PrimitiveType | undefined)[] = [];
+    (values as PrimitiveInstanceValue[]).forEach((val) => {
+      const primitiveType = val.genericType.value.rawType;
+      switch (primitiveType.path) {
+        case PRIMITIVE_TYPE.STRING:
+          addUniqueEntry(
+            valuePrimitiveTypes,
+            graph.getPrimitiveType(PRIMITIVE_TYPE.STRING),
+          );
+          break;
+        case PRIMITIVE_TYPE.INTEGER:
+        case PRIMITIVE_TYPE.DECIMAL:
+        case PRIMITIVE_TYPE.FLOAT:
+        case PRIMITIVE_TYPE.NUMBER:
+          addUniqueEntry(
+            valuePrimitiveTypes,
+            graph.getPrimitiveType(PRIMITIVE_TYPE.NUMBER),
+          );
+          break;
+        default:
+          valuePrimitiveTypes.push(undefined);
+          break;
+      }
+    });
+    if (valuePrimitiveTypes.length > 1) {
+      return undefined;
+    }
+    return valuePrimitiveTypes[0] as PrimitiveType;
+  } else if (values.every((val) => val instanceof EnumValueInstanceValue)) {
+    const valueEnumerationTypes: Enumeration[] = [];
+    (values as EnumValueInstanceValue[]).forEach((val) => {
+      addUniqueEntry(
+        valueEnumerationTypes,
+        guaranteeNonNullable(val.values[0]).value._OWNER,
+      );
+    });
+    if (valueEnumerationTypes.length > 1) {
+      return undefined;
+    }
+    return valueEnumerationTypes[0];
+  }
+  return undefined;
+};
+
+export const unwrapNotExpression = (
+  expression: SimpleFunctionExpression,
+): SimpleFunctionExpression | undefined => {
+  if (
+    matchFunctionName(
+      expression.functionName,
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.NOT,
+    )
+  ) {
+    return guaranteeType(
+      expression.parametersValues[0],
+      SimpleFunctionExpression,
+    );
+  }
+  return undefined;
+};
+
+export const buildNotExpression = (
+  graph: PureModel,
+  expression: ValueSpecification,
+): ValueSpecification => {
+  const multiplicityOne = graph.getTypicalMultiplicity(
+    TYPICAL_MULTIPLICITY_TYPE.ONE,
+  );
+  const expressionNot = new SimpleFunctionExpression(
+    extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.NOT),
+    multiplicityOne,
+  );
+  expressionNot.parametersValues.push(expression);
+  return expressionNot;
+};
+
+export const isPropertyExpressionChainOptional = (
+  expression: ValueSpecification | undefined,
+): boolean => {
+  let isOptional = false;
+  let propertyExpression = expression;
+  while (
+    propertyExpression &&
+    propertyExpression instanceof AbstractPropertyExpression
+  ) {
+    if (propertyExpression.func.multiplicity.lowerBound === 0) {
+      isOptional = true;
+      break;
+    }
+    propertyExpression = propertyExpression.parametersValues.at(0);
+    while (propertyExpression instanceof SimpleFunctionExpression) {
+      propertyExpression = propertyExpression.parametersValues.at(0);
+    }
+  }
+  return isOptional;
+};

package/src/stores/QueryBuilderPostFilterOperator.ts

@@ -0,0 +1,66 @@
+/**
+ * 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 {
+  FunctionExpression,
+  Type,
+  ValueSpecification,
+} from '@finos/legend-graph';
+import { uuid } from '@finos/legend-shared';
+import type {
+  PostFilterConditionState,
+  QueryBuilderPostFilterState,
+  TDS_COLUMN_GETTER,
+} from './QueryBuilderPostFilterState.js';
+
+export abstract class QueryBuilderPostFilterOperator {
+  readonly uuid = uuid();
+
+  abstract getLabel(): string;
+
+  getTdsColumnGetter(): TDS_COLUMN_GETTER | undefined {
+    return undefined;
+  }
+
+  abstract isCompatibleWithType(type: Type): boolean;
+
+  abstract isCompatibleWithConditionValue(
+    postFilterConditionState: PostFilterConditionState,
+  ): boolean;
+
+  abstract getDefaultFilterConditionValue(
+    postFilterConditionState: PostFilterConditionState,
+  ): ValueSpecification | undefined;
+
+  isCompatibleWithPostFilterColumn(
+    postFilterState: PostFilterConditionState,
+  ): boolean {
+    const columnType = postFilterState.columnState.getReturnType();
+    if (columnType) {
+      return this.isCompatibleWithType(columnType);
+    }
+    return false;
+  }
+
+  abstract buildPostFilterConditionExpression(
+    postFilterConditionState: PostFilterConditionState,
+  ): ValueSpecification | undefined;
+
+  abstract buildPostFilterConditionState(
+    postFilterState: QueryBuilderPostFilterState,
+    expression: FunctionExpression,
+  ): PostFilterConditionState | undefined;
+}

package/src/stores/QueryBuilderPostFilterProcessor.ts

@@ -0,0 +1,275 @@
+/**
+ * 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 LambdaFunctionInstanceValue,
+  AbstractPropertyExpression,
+  extractElementNameFromPath,
+  PrimitiveInstanceValue,
+  matchFunctionName,
+  VariableExpression,
+  FunctionExpression,
+} from '@finos/legend-graph';
+import {
+  assertTrue,
+  guaranteeIsString,
+  guaranteeNonNullable,
+  guaranteeType,
+  UnsupportedOperationError,
+} from '@finos/legend-shared';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../QueryBuilder_Const.js';
+import type { QueryBuilderAggregateColumnState } from './QueryBuilderAggregationState.js';
+import { toGroupOperation } from './QueryBuilderOperatorsHelper.js';
+import type { QueryBuilderPostFilterOperator } from './QueryBuilderPostFilterOperator.js';
+import {
+  type QueryBuilderPostFilterState,
+  getTDSColumnDerivedProperyFromType,
+  PostFilterConditionState,
+  QueryBuilderPostFilterTreeConditionNodeData,
+  QueryBuilderPostFilterTreeGroupNodeData,
+  TDS_COLUMN_GETTER,
+  getTypeFromDerivedProperty,
+} from './QueryBuilderPostFilterState.js';
+import {
+  type QueryBuilderProjectionColumnState,
+  QueryBuilderDerivationProjectionColumnState,
+} from './QueryBuilderProjectionState.js';
+
+export const findTdsColumnState = (
+  propertyExpression: AbstractPropertyExpression,
+  postFilterState: QueryBuilderPostFilterState,
+): QueryBuilderProjectionColumnState | QueryBuilderAggregateColumnState => {
+  const fetchStructureState =
+    postFilterState.queryBuilderState.fetchStructureState;
+  const properyExpressionName = propertyExpression.func.name;
+  assertTrue(
+    Object.values(TDS_COLUMN_GETTER).includes(
+      properyExpressionName as TDS_COLUMN_GETTER,
+    ),
+    `Can't process TDS column expression: TDS column property '${properyExpressionName}' not supported. Supported types are ${Object.values(
+      TDS_COLUMN_GETTER,
+    ).join(',')}`,
+  );
+  const tdsColumnGetter = properyExpressionName as TDS_COLUMN_GETTER;
+  const columnNameExpression = propertyExpression.parametersValues[1];
+  const columnName = guaranteeIsString(
+    guaranteeType(
+      columnNameExpression,
+      PrimitiveInstanceValue,
+      'Can`t process TDS column expression: Column should be a primitive instance value',
+    ).values[0],
+    'Can`t process TDS column expression: Column should be a string primitive instance value',
+  );
+  const columnStates = [
+    ...fetchStructureState.projectionState.aggregationState.columns,
+    ...fetchStructureState.projectionState.columns,
+  ];
+  const columnState = guaranteeNonNullable(
+    columnStates.find((c) => c.columnName === columnName),
+  );
+  if (
+    tdsColumnGetter !== TDS_COLUMN_GETTER.IS_NULL &&
+    tdsColumnGetter !== TDS_COLUMN_GETTER.IS_NOT_NULL
+  ) {
+    if (columnState instanceof QueryBuilderDerivationProjectionColumnState) {
+      const type = getTypeFromDerivedProperty(
+        tdsColumnGetter,
+        postFilterState.queryBuilderState.graphManagerState.graph,
+      );
+      if (type) {
+        columnState.setReturnType(type);
+      }
+      return columnState;
+    }
+    const columnType = guaranteeNonNullable(columnState.getReturnType());
+    assertTrue(
+      (getTDSColumnDerivedProperyFromType(columnType) as string) ===
+        tdsColumnGetter,
+      `Can't process TDS column expression: expected column type ${getTDSColumnDerivedProperyFromType(
+        columnType,
+      )} (got ${tdsColumnGetter})`,
+    );
+  }
+  return columnState;
+};
+
+export const buildPostFilterConditionState = (
+  postFilterState: QueryBuilderPostFilterState,
+  expression: FunctionExpression,
+  operatorFunctionFullPath: string | undefined,
+  operator: QueryBuilderPostFilterOperator,
+): PostFilterConditionState | undefined => {
+  let postConditionState: PostFilterConditionState | undefined;
+  const tdsColumnGetter = operator.getTdsColumnGetter();
+  if (
+    tdsColumnGetter &&
+    expression instanceof AbstractPropertyExpression &&
+    expression.func.name === tdsColumnGetter
+  ) {
+    const columnState = findTdsColumnState(expression, postFilterState);
+    postConditionState = new PostFilterConditionState(
+      postFilterState,
+      columnState,
+      undefined,
+      operator,
+    );
+    return postConditionState;
+  } else if (
+    operatorFunctionFullPath &&
+    matchFunctionName(expression.functionName, operatorFunctionFullPath)
+  ) {
+    assertTrue(
+      expression.parametersValues.length === 2,
+      `Can't process ${extractElementNameFromPath(
+        operatorFunctionFullPath,
+      )}() expression: ${extractElementNameFromPath(
+        operatorFunctionFullPath,
+      )}() expects '1 argument'`,
+    );
+
+    // get projection column
+    const tdsColumnPropertyExpression = guaranteeType(
+      expression.parametersValues[0],
+      AbstractPropertyExpression,
+      `Can't process ${extractElementNameFromPath(
+        operatorFunctionFullPath,
+      )}() expression: expects property expression in lambda body`,
+    );
+    const columnState = findTdsColumnState(
+      tdsColumnPropertyExpression,
+      postFilterState,
+    );
+
+    // get operation value specification
+    const value = expression.parametersValues[1];
+    // create state
+    postConditionState = new PostFilterConditionState(
+      postFilterState,
+      columnState,
+      value,
+      operator,
+    );
+
+    //post checks
+    assertTrue(
+      operator.isCompatibleWithPostFilterColumn(postConditionState),
+      `Can't process ${extractElementNameFromPath(
+        operatorFunctionFullPath,
+      )}() expression: property is not compatible with post-filter operator`,
+    );
+    assertTrue(
+      operator.isCompatibleWithConditionValue(postConditionState),
+      `Operator '${operator.getLabel()}' not compatible with value specification ${value?.toString()}`,
+    );
+  }
+  return postConditionState;
+};
+
+const processPostFilterExpression = (
+  expression: FunctionExpression,
+  postFilterState: QueryBuilderPostFilterState,
+  parentPostFilterNodeId: string | undefined,
+): void => {
+  const parentNode = parentPostFilterNodeId
+    ? postFilterState.getNode(parentPostFilterNodeId)
+    : undefined;
+  if (
+    [
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.AND,
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.OR,
+    ].some((fn) => matchFunctionName(expression.functionName, fn))
+  ) {
+    const groupNode = new QueryBuilderPostFilterTreeGroupNodeData(
+      parentPostFilterNodeId,
+      toGroupOperation(expression.functionName),
+    );
+    postFilterState.nodes.set(groupNode.id, groupNode);
+    expression.parametersValues.forEach((postFilterExpression) =>
+      processPostFilterExpression(
+        guaranteeType(
+          postFilterExpression,
+          FunctionExpression,
+          `Can't process post-filter group expression: each child expression must be a function expression`,
+        ),
+        postFilterState,
+        groupNode.id,
+      ),
+    );
+    postFilterState.addNodeFromNode(groupNode, parentNode);
+  } else {
+    for (const operator of postFilterState.operators) {
+      // NOTE: this allow plugin author to either return `undefined`
+      const postFilterConditionState = operator.buildPostFilterConditionState(
+        postFilterState,
+        expression,
+      );
+      if (postFilterConditionState) {
+        postFilterState.addNodeFromNode(
+          new QueryBuilderPostFilterTreeConditionNodeData(
+            undefined,
+            postFilterConditionState,
+          ),
+          parentNode,
+        );
+        return;
+      }
+    }
+    throw new UnsupportedOperationError(
+      `Can't process post-filter expression: no compatible post-filter operator processer available from plugins`,
+    );
+  }
+};
+
+export const processPostFilterLambda = (
+  postFilterLambda: LambdaFunctionInstanceValue,
+  postFilterState: QueryBuilderPostFilterState,
+): void => {
+  const fetchStructureState =
+    postFilterState.queryBuilderState.fetchStructureState;
+  assertTrue(
+    fetchStructureState.isProjectionMode(),
+    `Can't process post-filter lambda: post-filter lambda must use projection fetch structure`,
+  );
+  assertTrue(
+    Boolean(fetchStructureState.projectionState.columns.length),
+    `Can't process post-filter lambda: post-filter lambda must have at least one projection column `,
+  );
+  const lambdaFunc = guaranteeNonNullable(
+    postFilterLambda.values[0],
+    `Can't process post-filter lambda: post-filter lambda function is missing`,
+  );
+  assertTrue(
+    lambdaFunc.expressionSequence.length === 1,
+    `Can't process post-filter lambda: only support post-filter lambda body with 1 expression`,
+  );
+  const rootExpression = guaranteeType(
+    lambdaFunc.expressionSequence[0],
+    FunctionExpression,
+    `Can't process post-filter lambda: only support post-filter lambda body of type 'FunctionExpression'`,
+  );
+  assertTrue(
+    lambdaFunc.functionType.parameters.length === 1,
+    `Can't process post-filter lambda: only support post-filter lambda with 1 parameter`,
+  );
+  postFilterState.setLambdaParameterName(
+    guaranteeType(
+      lambdaFunc.functionType.parameters[0],
+      VariableExpression,
+      `Can't process post-filter lambda: only support filter() lambda with 1 parameter of type 'VariableExpression'`,
+    ).name,
+  );
+  processPostFilterExpression(rootExpression, postFilterState, undefined);
+};