@finos/legend-query-builder 0.0.1

package/src/graphManager/protocol/pure/v1/V1_QueryBuilder_FunctionExpressionBuilder.ts

@@ -0,0 +1,571 @@
+/**
+ * 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 {
+  assertNonNullable,
+  assertTrue,
+  assertType,
+  filterByType,
+  guaranteeType,
+  returnUndefOnError,
+} from '@finos/legend-shared';
+import {
+  type V1_GraphBuilderContext,
+  type V1_ProcessingContext,
+  type V1_ValueSpecification,
+  type ValueSpecification,
+  type SimpleFunctionExpression,
+  V1_buildBaseSimpleFunctionExpression,
+  V1_buildGenericFunctionExpression,
+  extractElementNameFromPath,
+  V1_AppliedProperty,
+  CollectionInstanceValue,
+  Multiplicity,
+  INTERNAL__UnknownValueSpecification,
+  V1_Variable,
+  V1_serializeValueSpecification,
+  GenericType,
+  GenericTypeExplicitReference,
+  matchFunctionName,
+  InstanceValue,
+  V1_AppliedFunction,
+  V1_Collection,
+  V1_Lambda,
+  V1_ValueSpecificationBuilder,
+  AbstractPropertyExpression,
+  TYPICAL_MULTIPLICITY_TYPE,
+  VariableExpression,
+  CORE_PURE_PATH,
+} from '@finos/legend-graph';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../QueryBuilderSupportedFunctions.js';
+
+const buildProjectionColumnLambda = (
+  valueSpecification: V1_ValueSpecification,
+  openVariables: string[],
+  compileContext: V1_GraphBuilderContext,
+  processingContext: V1_ProcessingContext,
+): ValueSpecification => {
+  assertType(
+    valueSpecification,
+    V1_Lambda,
+    `Can't build projection column: only support lambda`,
+  );
+
+  // lambda parameter
+  assertTrue(
+    valueSpecification.parameters.length === 1,
+    `Can't build projection column: only support lambda with 1 parameter`,
+  );
+  const columnLambdaParameter = guaranteeType(
+    valueSpecification.parameters[0],
+    V1_Variable,
+    `Can't build projection column: only support lambda with 1 parameter`,
+  );
+
+  // lambda body
+  assertTrue(
+    valueSpecification.body.length === 1,
+    `Can't build projection column: only support lambda body with 1 expression`,
+  );
+  let currentPropertyExpression: V1_ValueSpecification = valueSpecification
+    .body[0] as V1_ValueSpecification;
+  assertType(
+    currentPropertyExpression,
+    V1_AppliedProperty,
+    `Can't build projection column: only support lambda body as property expression`,
+  );
+  while (currentPropertyExpression instanceof V1_AppliedProperty) {
+    assertTrue(
+      currentPropertyExpression.parameters.length >= 1,
+      `Can't build projection column: only support lambda body as property expression`,
+    );
+    currentPropertyExpression = currentPropertyExpression
+      .parameters[0] as V1_ValueSpecification;
+    // Take care of chains of subtype (a pattern that is not useful, but we want to support and rectify)
+    // $x.employees->subType(@Person)->subType(@Staff)
+    while (
+      currentPropertyExpression instanceof V1_AppliedFunction &&
+      matchFunctionName(
+        currentPropertyExpression.function,
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.SUBTYPE,
+      )
+    ) {
+      currentPropertyExpression = currentPropertyExpression
+        .parameters[0] as V1_ValueSpecification;
+    }
+  }
+  // check lambda variable and parameter match
+  assertType(
+    currentPropertyExpression,
+    V1_Variable,
+    `Can't build projection column: only support lambda body as property expression`,
+  );
+  assertTrue(
+    columnLambdaParameter.name === currentPropertyExpression.name,
+    `Can't build column lambda: expects variable used in lambda body '${currentPropertyExpression.name}' to match lambda parameter '${columnLambdaParameter.name}'`,
+  );
+  return valueSpecification.accept_ValueSpecificationVisitor(
+    new V1_ValueSpecificationBuilder(
+      compileContext,
+      processingContext,
+      openVariables,
+    ),
+  );
+};
+
+const buildAggregationExpression = (
+  valueSpecification: V1_ValueSpecification,
+  openVariables: string[],
+  compileContext: V1_GraphBuilderContext,
+  processingContext: V1_ProcessingContext,
+): ValueSpecification => {
+  assertType(
+    valueSpecification,
+    V1_AppliedFunction,
+    `Can't build aggregation: only support function`,
+  );
+  assertTrue(
+    matchFunctionName(
+      valueSpecification.function,
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_AGG,
+    ),
+    `Can't build aggregation: only support agg()`,
+  );
+
+  assertTrue(
+    valueSpecification.parameters.length === 2,
+    `Can't build agg() expression: agg() expects 2 arguments`,
+  );
+
+  // column lambda
+  const columnLambda = guaranteeType(
+    valueSpecification.parameters[0],
+    V1_Lambda,
+    `Can't build agg() expression: agg() expects argument #1 as a lambda`,
+  );
+  const processedColumnLambda =
+    returnUndefOnError(() =>
+      buildProjectionColumnLambda(
+        columnLambda,
+        openVariables,
+        compileContext,
+        processingContext,
+      ),
+    ) ??
+    new INTERNAL__UnknownValueSpecification(
+      V1_serializeValueSpecification(columnLambda),
+    );
+
+  // aggregate lambda
+  const aggregateLambda = guaranteeType(
+    valueSpecification.parameters[1],
+    V1_Lambda,
+  );
+  const processedAggregateLambda =
+    aggregateLambda.accept_ValueSpecificationVisitor(
+      new V1_ValueSpecificationBuilder(
+        compileContext,
+        processingContext,
+        openVariables,
+      ),
+    );
+
+  return V1_buildBaseSimpleFunctionExpression(
+    [processedColumnLambda, processedAggregateLambda],
+    extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_AGG),
+    compileContext,
+  );
+};
+
+export const V1_buildGetAllFunctionExpression = (
+  functionName: string,
+  parameters: V1_ValueSpecification[],
+  openVariables: string[],
+  compileContext: V1_GraphBuilderContext,
+  processingContext: V1_ProcessingContext,
+): [SimpleFunctionExpression, ValueSpecification[]] => {
+  const [expression, processedParams] = V1_buildGenericFunctionExpression(
+    functionName,
+    parameters,
+    openVariables,
+    compileContext,
+    processingContext,
+  );
+  const precedingExpression = expression.parametersValues[0];
+
+  assertType(
+    precedingExpression,
+    InstanceValue,
+    `Can't build getAll() expression: only support getAll() immediately following a class`,
+  );
+  expression.genericType = precedingExpression.genericType;
+  expression.multiplicity = precedingExpression.multiplicity;
+  return [expression, processedParams];
+};
+
+export const V1_buildExistsFunctionExpression = (
+  functionName: string,
+  parameters: V1_ValueSpecification[],
+  openVariables: string[],
+  compileContext: V1_GraphBuilderContext,
+  processingContext: V1_ProcessingContext,
+): [SimpleFunctionExpression, ValueSpecification[]] => {
+  assertTrue(
+    parameters.length === 2,
+    `Can't build exists() expression: exists() expects 1 argument`,
+  );
+
+  const precedingExpression = (
+    parameters[0] as V1_ValueSpecification
+  ).accept_ValueSpecificationVisitor(
+    new V1_ValueSpecificationBuilder(
+      compileContext,
+      processingContext,
+      openVariables,
+    ),
+  );
+  precedingExpression.genericType = guaranteeType(
+    precedingExpression,
+    AbstractPropertyExpression,
+  ).func.genericType;
+  const lambda = parameters[1];
+  if (lambda instanceof V1_Lambda) {
+    lambda.parameters.forEach((variable): void => {
+      if (variable.name && !variable.class) {
+        const variableExpression = new VariableExpression(
+          variable.name,
+          compileContext.graph.getTypicalMultiplicity(
+            TYPICAL_MULTIPLICITY_TYPE.ONE,
+          ),
+        );
+        variableExpression.genericType = precedingExpression.genericType;
+        processingContext.addInferredVariables(
+          variable.name,
+          variableExpression,
+        );
+      }
+    });
+  }
+  const processedParameters = [
+    precedingExpression,
+    (parameters[1] as V1_ValueSpecification).accept_ValueSpecificationVisitor(
+      new V1_ValueSpecificationBuilder(
+        compileContext,
+        processingContext,
+        openVariables,
+      ),
+    ),
+  ];
+  const expression = V1_buildBaseSimpleFunctionExpression(
+    processedParameters,
+    functionName,
+    compileContext,
+  );
+  return [expression, processedParameters];
+};
+
+export const V1_buildFilterFunctionExpression = (
+  functionName: string,
+  parameters: V1_ValueSpecification[],
+  openVariables: string[],
+  compileContext: V1_GraphBuilderContext,
+  processingContext: V1_ProcessingContext,
+): [SimpleFunctionExpression, ValueSpecification[]] => {
+  assertTrue(
+    parameters.length === 2,
+    `Can't build filter() expression: filter() expects 1 argument`,
+  );
+  const precedingExpression = (
+    parameters[0] as V1_ValueSpecification
+  ).accept_ValueSpecificationVisitor(
+    new V1_ValueSpecificationBuilder(
+      compileContext,
+      processingContext,
+      openVariables,
+    ),
+  );
+  if (precedingExpression.genericType) {
+    const lambda = parameters[1];
+    if (lambda instanceof V1_Lambda) {
+      lambda.parameters.forEach((variable): void => {
+        if (variable.name && !variable.class) {
+          const variableExpression = new VariableExpression(
+            variable.name,
+            precedingExpression.multiplicity,
+          );
+          variableExpression.genericType = precedingExpression.genericType;
+          processingContext.addInferredVariables(
+            variable.name,
+            variableExpression,
+          );
+        }
+      });
+    }
+  }
+  const processedParams = [
+    precedingExpression,
+    (parameters[1] as V1_ValueSpecification).accept_ValueSpecificationVisitor(
+      new V1_ValueSpecificationBuilder(
+        compileContext,
+        processingContext,
+        openVariables,
+      ),
+    ),
+  ];
+  const expression = V1_buildBaseSimpleFunctionExpression(
+    processedParams,
+    functionName,
+    compileContext,
+  );
+
+  // return type of filter() is the same as that of the function precedes it
+  expression.genericType = precedingExpression.genericType;
+  expression.multiplicity = precedingExpression.multiplicity;
+  return [expression, processedParams];
+};
+
+export const V1_buildProjectFunctionExpression = (
+  functionName: string,
+  parameters: V1_ValueSpecification[],
+  openVariables: string[],
+  compileContext: V1_GraphBuilderContext,
+  processingContext: V1_ProcessingContext,
+): [SimpleFunctionExpression, ValueSpecification[]] => {
+  assertTrue(
+    parameters.length === 3,
+    `Can't build 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 project() expression: preceding expression return type is missing`,
+  );
+
+  const columnExpressions = parameters[1];
+  assertType(
+    columnExpressions,
+    V1_Collection,
+    `Can't build project() expression: project() expects argument #1 to be a collection`,
+  );
+  topLevelLambdaParameters = columnExpressions.values
+    .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);
+    }
+  });
+
+  // build column expressions taking into account of derivation
+  const processedColumnExpressions = new CollectionInstanceValue(
+    new Multiplicity(
+      columnExpressions.multiplicity.lowerBound,
+      columnExpressions.multiplicity.upperBound,
+    ),
+  );
+  processedColumnExpressions.values = columnExpressions.values.map((value) => {
+    try {
+      return buildProjectionColumnLambda(
+        value,
+        openVariables,
+        compileContext,
+        processingContext,
+      );
+    } catch {
+      return new INTERNAL__UnknownValueSpecification(
+        V1_serializeValueSpecification(value),
+      );
+    }
+  });
+
+  const processedParams = [
+    precedingExperession,
+    processedColumnExpressions,
+    (parameters[2] as V1_ValueSpecification).accept_ValueSpecificationVisitor(
+      new V1_ValueSpecificationBuilder(
+        compileContext,
+        processingContext,
+        openVariables,
+      ),
+    ),
+  ];
+  const expression = V1_buildBaseSimpleFunctionExpression(
+    processedParams,
+    functionName,
+    compileContext,
+  );
+  expression.genericType = GenericTypeExplicitReference.create(
+    new GenericType(compileContext.resolveType(CORE_PURE_PATH.TDS_ROW).value),
+  );
+  return [expression, processedParams];
+};
+
+export const V1_buildGroupByFunctionExpression = (
+  functionName: string,
+  parameters: V1_ValueSpecification[],
+  openVariables: string[],
+  compileContext: V1_GraphBuilderContext,
+  processingContext: V1_ProcessingContext,
+): [SimpleFunctionExpression, ValueSpecification[]] => {
+  let topLevelLambdaParameters: V1_Variable[] = [];
+  assertTrue(
+    parameters.length === 4,
+    `Can't build groupBy() expression: groupBy() expects 3 arguments`,
+  );
+
+  const precedingExperession = (
+    parameters[0] as V1_ValueSpecification
+  ).accept_ValueSpecificationVisitor(
+    new V1_ValueSpecificationBuilder(
+      compileContext,
+      processingContext,
+      openVariables,
+    ),
+  );
+  assertNonNullable(
+    precedingExperession.genericType,
+    `Can't build groupBy() expression: preceding expression return type is missing`,
+  );
+
+  // normal columns
+  const columnExpressions = parameters[1];
+  assertType(
+    columnExpressions,
+    V1_Collection,
+    `Can't build groupBy() expression: groupBy() expects argument #1 to be a collection`,
+  );
+  topLevelLambdaParameters = columnExpressions.values
+    .filter(filterByType(V1_Lambda))
+    .map((lambda) => lambda.parameters)
+    .flat();
+
+  // aggregation columns
+  const aggregationExpressions = parameters[2];
+  assertType(
+    aggregationExpressions,
+    V1_Collection,
+    `Can't build groupBy() expression: groupBy() expects argument #2 to be a collection`,
+  );
+  topLevelLambdaParameters = topLevelLambdaParameters.concat(
+    aggregationExpressions.values
+      .filter(
+        (value: V1_ValueSpecification): value is V1_AppliedFunction =>
+          value instanceof V1_AppliedFunction &&
+          matchFunctionName(
+            value.function,
+            QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_AGG,
+          ),
+      )
+      .map((value) => value.parameters)
+      .flat()
+      .filter(filterByType(V1_Lambda))
+      .map((lambda) => lambda.parameters)
+      .flat(),
+  );
+
+  // Make sure top-level lambdas have their lambda parameter types set properly
+  const variables = new Set<string>();
+  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);
+    }
+  });
+
+  // build column expressions taking into account of derivation
+  const processedColumnExpressions = new CollectionInstanceValue(
+    new Multiplicity(
+      columnExpressions.multiplicity.lowerBound,
+      columnExpressions.multiplicity.upperBound,
+    ),
+  );
+  processedColumnExpressions.values = columnExpressions.values.map((value) => {
+    try {
+      return buildProjectionColumnLambda(
+        value,
+        openVariables,
+        compileContext,
+        processingContext,
+      );
+    } catch {
+      return new INTERNAL__UnknownValueSpecification(
+        V1_serializeValueSpecification(value),
+      );
+    }
+  });
+
+  // build aggregation expressions taking into account of derivation
+  const processedAggregationExpressions = new CollectionInstanceValue(
+    new Multiplicity(
+      aggregationExpressions.multiplicity.lowerBound,
+      aggregationExpressions.multiplicity.upperBound,
+    ),
+  );
+  processedAggregationExpressions.values = aggregationExpressions.values.map(
+    (value) =>
+      buildAggregationExpression(
+        value,
+        openVariables,
+        compileContext,
+        processingContext,
+      ),
+  );
+
+  const processedParams = [
+    precedingExperession,
+    processedColumnExpressions,
+    processedAggregationExpressions,
+    (parameters[3] as V1_ValueSpecification).accept_ValueSpecificationVisitor(
+      new V1_ValueSpecificationBuilder(
+        compileContext,
+        processingContext,
+        openVariables,
+      ),
+    ),
+  ];
+  const expression = V1_buildBaseSimpleFunctionExpression(
+    processedParams,
+    functionName,
+    compileContext,
+  );
+  expression.genericType = GenericTypeExplicitReference.create(
+    new GenericType(compileContext.resolveType(CORE_PURE_PATH.TDS_ROW).value),
+  );
+  return [expression, processedParams];
+};

package/src/graphManager/protocol/pure/v1/V1_QueryBuilder_PropertyExpressionTypeInferenceBuilder.ts

@@ -0,0 +1,28 @@
+/**
+ * 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 SimpleFunctionExpression,
+  type Type,
+  InstanceValue,
+} from '@finos/legend-graph';
+
+export const V1_buildSubTypePropertyExpressionTypeInference = (
+  inferredVariable: SimpleFunctionExpression,
+): Type | undefined =>
+  inferredVariable.parametersValues.filter(
+    (param) => param instanceof InstanceValue,
+  )[0]?.genericType?.value.rawType;