@finos/legend-query-builder 0.3.1 → 0.4.1

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

@@ -19,6 +19,7 @@ import {
   assertTrue,
   assertType,
   filterByType,
+  guaranteeNonNullable,
   guaranteeType,
   returnUndefOnError,
 } from '@finos/legend-shared';
@@ -49,6 +50,7 @@ import {
   TYPICAL_MULTIPLICITY_TYPE,
   VariableExpression,
   CORE_PURE_PATH,
+  PRIMITIVE_TYPE,
 } from '@finos/legend-graph';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../QueryBuilderSupportedFunctions.js';
 
@@ -325,6 +327,7 @@ export const V1_buildFilterFunctionExpression = (
       ),
     ),
   ];
+
   const expression = V1_buildBaseSimpleFunctionExpression(
     processedParams,
     functionName,
@@ -570,6 +573,79 @@ export const V1_buildGroupByFunctionExpression = (
   return [expression, processedParams];
 };
 
+export const V1_buildWatermarkFunctionExpression = (
+  functionName: string,
+  parameters: V1_ValueSpecification[],
+  openVariables: string[],
+  compileContext: V1_GraphBuilderContext,
+  processingContext: V1_ProcessingContext,
+): [SimpleFunctionExpression, ValueSpecification[]] | undefined => {
+  assertTrue(
+    parameters.length === 2,
+    `Can't build forWatermark() expression: forWatermark() expects 1 argument`,
+  );
+  const precedingExpression = (
+    parameters[0] as V1_ValueSpecification
+  ).accept_ValueSpecificationVisitor(
+    new V1_ValueSpecificationBuilder(
+      compileContext,
+      processingContext,
+      openVariables,
+    ),
+  );
+  assertNonNullable(
+    precedingExpression.genericType,
+    `Can't build forWatermark() expression: preceding expression return type is missing`,
+  );
+
+  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 watermarkValueParam = guaranteeNonNullable(processedParams[1]);
+  const watermarkValueParamType =
+    watermarkValueParam.genericType?.value.rawType;
+  assertTrue(
+    compileContext.graph.getPrimitiveType(PRIMITIVE_TYPE.STRING) ===
+      watermarkValueParamType,
+    "Can't build forWatermark() expression: watermark parameter is expected to be of type string.",
+  );
+
+  const expression = V1_buildBaseSimpleFunctionExpression(
+    processedParams,
+    functionName,
+    compileContext,
+  );
+
+  expression.genericType = precedingExpression.genericType;
+  expression.multiplicity = precedingExpression.multiplicity;
+  return [expression, processedParams];
+};
+
 export const V1_buildOlapGroupByFunctionExpression = (
   functionName: string,
   parameters: V1_ValueSpecification[],

package/src/stores/QueryBuilderState.ts

@@ -75,6 +75,7 @@ import { QueryBuilderChangeDetectionState } from './QueryBuilderChangeDetectionS
 import { QueryBuilderMilestoningState } from './QueryBuilderMilestoningState.js';
 import { QUERY_BUILDER_HASH_STRUCTURE } from '../graphManager/QueryBuilderHashUtils.js';
 import { QUERY_BUILDER_COMMAND_KEY } from './QueryBuilderCommand.js';
+import { QueryBuilderWatermarkState } from './watermark/QueryBuilderWatermarkState.js';
 
 export abstract class QueryBuilderState implements CommandRegistrar {
   applicationStore: GenericLegendApplicationStore;
@@ -87,6 +88,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
   milestoningState: QueryBuilderMilestoningState;
   fetchStructureState: QueryBuilderFetchStructureState;
   filterState: QueryBuilderFilterState;
+  watermarkState: QueryBuilderWatermarkState;
   filterOperators: QueryBuilderFilterOperator[] =
     getQueryBuilderCoreFilterOperators();
   resultState: QueryBuilderResultState;
@@ -97,6 +99,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
   queryCompileState = ActionState.create();
   showFunctionsExplorerPanel = false;
   showParametersPanel = false;
+  isEditingWatermark = false;
 
   class?: Class | undefined;
   mapping?: Mapping | undefined;
@@ -116,11 +119,13 @@ export abstract class QueryBuilderState implements CommandRegistrar {
       functionsExplorerState: observable,
       fetchStructureState: observable,
       filterState: observable,
+      watermarkState: observable,
       resultState: observable,
       textEditorState: observable,
       unsupportedQueryState: observable,
       showFunctionsExplorerPanel: observable,
       showParametersPanel: observable,
+      isEditingWatermark: observable,
       changeDetectionState: observable,
       class: observable,
       mapping: observable,
@@ -132,6 +137,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
 
       setShowFunctionsExplorerPanel: action,
       setShowParametersPanel: action,
+      setIsEditingWatermark: action,
       setClass: action,
       setMapping: action,
       setRuntimeValue: action,
@@ -156,6 +162,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
     this.functionsExplorerState = new QueryFunctionsExplorerState(this);
     this.fetchStructureState = new QueryBuilderFetchStructureState(this);
     this.filterState = new QueryBuilderFilterState(this, this.filterOperators);
+    this.watermarkState = new QueryBuilderWatermarkState(this);
     this.resultState = new QueryBuilderResultState(this);
     this.textEditorState = new QueryBuilderTextEditorState(this);
     this.unsupportedQueryState = new QueryBuilderUnsupportedQueryState(this);
@@ -201,6 +208,10 @@ export abstract class QueryBuilderState implements CommandRegistrar {
     this.showParametersPanel = val;
   }
 
+  setIsEditingWatermark(val: boolean): void {
+    this.isEditingWatermark = val;
+  }
+
   setClass(val: Class | undefined): void {
     this.class = val;
   }
@@ -249,6 +260,8 @@ export abstract class QueryBuilderState implements CommandRegistrar {
     this.parametersState = new QueryBuilderParametersState(this);
     this.functionsExplorerState = new QueryFunctionsExplorerState(this);
     this.filterState = new QueryBuilderFilterState(this, this.filterOperators);
+    this.watermarkState = new QueryBuilderWatermarkState(this);
+
     const currentFetchStructureImplementationType =
       this.fetchStructureState.implementation.type;
     this.fetchStructureState = new QueryBuilderFetchStructureState(this);
@@ -482,6 +495,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
       this.milestoningState,
       this.parametersState,
       this.filterState,
+      this.watermarkState,
       this.fetchStructureState.implementation,
     ]);
   }

package/src/stores/QueryBuilderStateBuilder.ts

@@ -71,6 +71,7 @@ import {
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../graphManager/QueryBuilderSupportedFunctions.js';
 import { LambdaParameterState } from './shared/LambdaParameterState.js';
 import { processTDSOlapGroupByExpression } from './fetch-structure/tds/olapGroupBy/QueryBuilderOlapGroupByStateBuilder.js';
+import { processWatermarkExpression } from './watermark/QueryBuilderWatermarkStateBuilder.js';
 
 const processGetAllExpression = (
   expression: SimpleFunctionExpression,
@@ -410,11 +411,26 @@ export class QueryBuilderValueSpecificationProcessor
           this.queryBuilderState,
         );
         return;
+      } else if (
+        matchFunctionName(precedingExpression.functionName, [
+          QUERY_BUILDER_SUPPORTED_FUNCTIONS.WATERMARK,
+        ])
+      ) {
+        processFilterExpression(valueSpecification, this.queryBuilderState);
+        return;
       } else {
         throw new UnsupportedOperationError(
-          `Can't process filter() expression: only support filter() immediately following getAll() or project()/groupBy()/olapGroupBy()`,
+          `Can't process filter() expression: only support filter() immediately following getAll() or project()/forWatermark()/groupBy()/olapGroupBy()`,
         );
       }
+    } else if (
+      matchFunctionName(
+        functionName,
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.WATERMARK,
+      )
+    ) {
+      processWatermarkExpression(valueSpecification, this.queryBuilderState);
+      return;
     } else if (
       matchFunctionName(
         functionName,

package/src/stores/QueryBuilderValueSpecificationBuilder.ts

@@ -37,6 +37,7 @@ import type { LambdaFunctionBuilderOption } from './QueryBuilderValueSpecificati
 import type { QueryBuilderFetchStructureState } from './fetch-structure/QueryBuilderFetchStructureState.js';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../graphManager/QueryBuilderSupportedFunctions.js';
 import { buildParametersLetLambdaFunc } from './shared/LambdaParameterState.js';
+import { buildWatermarkExpression } from './watermark/QueryBuilderWatermarkValueSpecificationBuilder.js';
 
 const buildGetAllFunction = (
   _class: Class,
@@ -136,10 +137,19 @@ export const buildLambdaFunction = (
   }
   lambdaFunction.expressionSequence[0] = getAllFunction;
 
+  // build watermark
+  const watermarkFunction = buildWatermarkExpression(
+    queryBuilderState.watermarkState,
+    getAllFunction,
+  );
+  if (watermarkFunction) {
+    lambdaFunction.expressionSequence[0] = watermarkFunction;
+  }
+
   // build filter
   const filterFunction = buildFilterExpression(
     queryBuilderState.filterState,
-    getAllFunction,
+    watermarkFunction ?? getAllFunction,
   );
   if (filterFunction) {
     lambdaFunction.expressionSequence[0] = filterFunction;

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

@@ -81,8 +81,9 @@ export const processTDSProjectExpression = (
     matchFunctionName(precedingExpression.functionName, [
       QUERY_BUILDER_SUPPORTED_FUNCTIONS.GET_ALL,
       QUERY_BUILDER_SUPPORTED_FUNCTIONS.FILTER,
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.WATERMARK,
     ]),
-    `Can't process project() expression: only support project() immediately following either getAll() or filter()`,
+    `Can't process project() expression: only support project() immediately following either getAll(), filter(), or forWatermark()`,
   );
   QueryBuilderValueSpecificationProcessor.process(
     precedingExpression,

package/src/stores/watermark/QueryBuilderWatermarkState.ts

@@ -0,0 +1,114 @@
+/**
+ * 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 ValueSpecification,
+  observe_ValueSpecification,
+  GenericTypeExplicitReference,
+  GenericType,
+  PRIMITIVE_TYPE,
+  PrimitiveInstanceValue,
+  TYPICAL_MULTIPLICITY_TYPE,
+  multiplicityComparator,
+  type VariableExpression,
+} from '@finos/legend-graph';
+import { type Hashable, hashArray } from '@finos/legend-shared';
+import { makeObservable, observable, action, computed } from 'mobx';
+import { QUERY_BUILDER_HASH_STRUCTURE } from '../../graphManager/QueryBuilderHashUtils.js';
+import type { QueryBuilderState } from '../QueryBuilderState.js';
+
+export class QueryBuilderWatermarkState implements Hashable {
+  readonly queryBuilderState: QueryBuilderState;
+  value?: ValueSpecification | undefined;
+  isEditingWatermark = false;
+
+  constructor(queryBuilderState: QueryBuilderState) {
+    makeObservable(this, {
+      value: observable,
+      isEditingWatermark: observable,
+      setValue: action,
+      resetValue: action,
+      enableWatermark: action,
+      setIsEditingWatermark: action,
+      hashCode: computed,
+    });
+
+    this.queryBuilderState = queryBuilderState;
+  }
+
+  isParamaterCompatibleWithWaterMark = (
+    parameter: VariableExpression,
+  ): boolean => {
+    const isString =
+      this.queryBuilderState.graphManagerState.graph.getPrimitiveType(
+        PRIMITIVE_TYPE.STRING,
+      ) === parameter.genericType?.value.rawType;
+
+    const isMultiplictyOne = multiplicityComparator(
+      parameter.multiplicity,
+      this.queryBuilderState.graphManagerState.graph.getTypicalMultiplicity(
+        TYPICAL_MULTIPLICITY_TYPE.ONE,
+      ),
+    );
+    return isString && isMultiplictyOne;
+  };
+
+  resetValue(): void {
+    const watermarkConstant = new PrimitiveInstanceValue(
+      GenericTypeExplicitReference.create(
+        new GenericType(
+          this.queryBuilderState.graphManagerState.graph.getPrimitiveType(
+            PRIMITIVE_TYPE.STRING,
+          ),
+        ),
+      ),
+      this.queryBuilderState.graphManagerState.graph.getTypicalMultiplicity(
+        TYPICAL_MULTIPLICITY_TYPE.ONE,
+      ),
+    );
+
+    watermarkConstant.values = ['watermarkValue'];
+    this.setValue(watermarkConstant);
+  }
+
+  setIsEditingWatermark(val: boolean): void {
+    this.isEditingWatermark = val;
+  }
+
+  enableWatermark(): void {
+    if (this.value) {
+      this.setValue(undefined);
+    } else {
+      this.resetValue();
+    }
+  }
+
+  setValue(val: ValueSpecification | undefined): void {
+    this.value = val
+      ? observe_ValueSpecification(
+          val,
+          this.queryBuilderState.observableContext,
+        )
+      : undefined;
+  }
+
+  get hashCode(): string {
+    return hashArray([
+      QUERY_BUILDER_HASH_STRUCTURE.WATERMARK_STATE,
+      this.value ?? '',
+    ]);
+  }
+}

package/src/stores/watermark/QueryBuilderWatermarkStateBuilder.ts

@@ -0,0 +1,50 @@
+/**
+ * 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 {
+  SimpleFunctionExpression,
+  matchFunctionName,
+} from '@finos/legend-graph';
+import { assertTrue, guaranteeType } from '@finos/legend-shared';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../graphManager/QueryBuilderSupportedFunctions.js';
+import type { QueryBuilderState } from '../QueryBuilderState.js';
+import { QueryBuilderValueSpecificationProcessor } from '../QueryBuilderStateBuilder.js';
+
+export const processWatermarkExpression = (
+  expression: SimpleFunctionExpression,
+  queryBuilderState: QueryBuilderState,
+): void => {
+  // check preceding expression
+  const precedingExpression = guaranteeType(
+    expression.parametersValues[0],
+    SimpleFunctionExpression,
+    `Can't process forWatermark() expression: only support forWatermark() immediately following an expression`,
+  );
+  assertTrue(
+    matchFunctionName(precedingExpression.functionName, [
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.GET_ALL,
+    ]),
+    `Can't process forWatermark() expression: only support forWatermark() immediately following getAll()`,
+  );
+
+  QueryBuilderValueSpecificationProcessor.process(
+    precedingExpression,
+    queryBuilderState,
+  );
+
+  const watermarkValue = expression.parametersValues[1];
+  queryBuilderState.watermarkState.setValue(watermarkValue);
+};

package/src/stores/watermark/QueryBuilderWatermarkValueSpecificationBuilder.ts

@@ -0,0 +1,46 @@
+/**
+ * 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 {
+  SimpleFunctionExpression,
+  extractElementNameFromPath,
+  type VariableExpression,
+} from '@finos/legend-graph';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../graphManager/QueryBuilderSupportedFunctions.js';
+import type { QueryBuilderWatermarkState } from './QueryBuilderWatermarkState.js';
+
+export const buildWatermarkExpression = (
+  watermarkState: QueryBuilderWatermarkState,
+  getAllFunc: SimpleFunctionExpression,
+): SimpleFunctionExpression | undefined => {
+  if (!watermarkState.value) {
+    return undefined;
+  }
+
+  // main filter expression
+  const watermarkExpression = new SimpleFunctionExpression(
+    extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.WATERMARK),
+    (watermarkState.value as VariableExpression).multiplicity,
+  );
+
+  // param [0]
+  watermarkExpression.parametersValues.push(getAllFunc);
+
+  // param [1]
+  watermarkExpression.parametersValues.push(watermarkState.value);
+
+  return watermarkExpression;
+};

package/tsconfig.json

@@ -150,6 +150,9 @@
     "./src/stores/shared/LambdaParameterState.ts",
     "./src/stores/shared/ValueSpecificationEditorHelper.ts",
     "./src/stores/shared/ValueSpecificationModifierHelper.ts",
+    "./src/stores/watermark/QueryBuilderWatermarkState.ts",
+    "./src/stores/watermark/QueryBuilderWatermarkStateBuilder.ts",
+    "./src/stores/watermark/QueryBuilderWatermarkValueSpecificationBuilder.ts",
     "./src/stores/workflows/ClassQueryBuilderState.ts",
     "./src/stores/workflows/MappingQueryBuilderState.ts",
     "./src/stores/workflows/ServiceQueryBuilderState.ts",
@@ -184,6 +187,7 @@
     "./src/components/shared/LambdaParameterValuesEditor.tsx",
     "./src/components/shared/QueryBuilderPanelIssueCountBadge.tsx",
     "./src/components/shared/QueryBuilderPropertyInfoTooltip.tsx",
+    "./src/components/watermark/QueryBuilderWatermark.tsx",
     "./src/components/workflows/ClassQueryBuilder.tsx",
     "./src/components/workflows/MappingQueryBuilder.tsx",
     "./src/components/workflows/ServiceQueryBuilder.tsx"