@finos/legend-application-query 5.2.6 → 6.0.0

package/lib/stores/QueryBuilderValueSpecificationProcessor.d.ts

@@ -1,56 +0,0 @@
-/**
- * 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 { QueryBuilderState } from './QueryBuilderState.js';
-import { type AlloySerializationConfigInstanceValue, type EnumValueInstanceValue, type FunctionExpression, type MappingInstanceValue, type PairInstanceValue, type PropertyGraphFetchTreeInstanceValue, type PureListInstanceValue, type RootGraphFetchTreeInstanceValue, type RuntimeInstanceValue, type ValueSpecificationVisitor, type InstanceValue, type INTERNAL__UnknownValueSpecification, type LambdaFunction, CollectionInstanceValue, LambdaFunctionInstanceValue, PrimitiveInstanceValue, SimpleFunctionExpression, VariableExpression, AbstractPropertyExpression, type INTERNAL__PropagatedValue } from '@finos/legend-graph';
-/**
- * This is the expression processor for query builder.
- * Unlike expression builder which takes care of transforming the value specification
- * from `protocol` to `metamodel`, and type-inferencing, this takes care
- * of traversing the expression to populate the query builder UI state.
- *
- * NOTE: While traversing the expression, this processor also does a fair amount of
- * validations and assertsions but just so enough to populate the UI state.
- *
- * Validation and assertion should be done by both the builder and processor, but the builder
- * will do more structural checks to build the proper metamodel. The processor should never
- * modify the metamodel, just traversing it.
- */
-export declare class QueryBuilderLambdaProcessor implements ValueSpecificationVisitor<void> {
-    queryBuilderState: QueryBuilderState;
-    precedingExpression?: SimpleFunctionExpression | undefined;
-    constructor(queryBuilderState: QueryBuilderState, precedingExpression: SimpleFunctionExpression | undefined);
-    visit_INTERNAL__UnknownValueSpecification(valueSpecification: INTERNAL__UnknownValueSpecification): void;
-    visit_RootGraphFetchTreeInstanceValue(valueSpecification: RootGraphFetchTreeInstanceValue): void;
-    visit_PropertyGraphFetchTreeInstanceValue(valueSpecification: PropertyGraphFetchTreeInstanceValue): void;
-    visit_AlloySerializationConfigInstanceValue(valueSpecification: AlloySerializationConfigInstanceValue): void;
-    visit_PrimitiveInstanceValue(valueSpecification: PrimitiveInstanceValue): void;
-    visit_EnumValueInstanceValue(valueSpecification: EnumValueInstanceValue): void;
-    visit_RuntimeInstanceValue(valueSpecification: RuntimeInstanceValue): void;
-    visit_PairInstanceValue(valueSpecification: PairInstanceValue): void;
-    visit_MappingInstanceValue(valueSpecification: MappingInstanceValue): void;
-    visit_PureListInstanceValue(valueSpecification: PureListInstanceValue): void;
-    visit_CollectionInstanceValue(valueSpecification: CollectionInstanceValue): void;
-    visit_FunctionExpression(valueSpecification: FunctionExpression): void;
-    visit_INTERNAL__PropagatedValue(valueSpecification: INTERNAL__PropagatedValue): void;
-    visit_SimpleFunctionExpression(valueSpecification: SimpleFunctionExpression): void;
-    visit_VariableExpression(valueSpecification: VariableExpression): void;
-    visit_LambdaFunctionInstanceValue(valueSpecification: LambdaFunctionInstanceValue): void;
-    visit_AbstractPropertyExpression(valueSpecification: AbstractPropertyExpression): void;
-    visit_InstanceValue(valueSpecification: InstanceValue): void;
-}
-export declare const processQueryParameters: (parameters: VariableExpression[], queryBuilderState: QueryBuilderState) => void;
-export declare const processQueryBuilderLambdaFunction: (queryBuilderState: QueryBuilderState, lambdaFunc: LambdaFunction) => void;
-//# sourceMappingURL=QueryBuilderValueSpecificationProcessor.d.ts.map

package/lib/stores/QueryBuilderValueSpecificationProcessor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"QueryBuilderValueSpecificationProcessor.d.ts","sourceRoot":"","sources":["../../src/stores/QueryBuilderValueSpecificationProcessor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAeH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAWhE,OAAO,EACL,KAAK,qCAAqC,EAC1C,KAAK,sBAAsB,EAC3B,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EACzB,KAAK,iBAAiB,EACtB,KAAK,mCAAmC,EACxC,KAAK,qBAAqB,EAC1B,KAAK,+BAA+B,EACpC,KAAK,oBAAoB,EAEzB,KAAK,yBAAyB,EAC9B,KAAK,aAAa,EAClB,KAAK,mCAAmC,EACxC,KAAK,cAAc,EAMnB,uBAAuB,EAEvB,2BAA2B,EAC3B,sBAAsB,EAEtB,wBAAwB,EACxB,kBAAkB,EAClB,0BAA0B,EAI1B,KAAK,yBAAyB,EAE/B,MAAM,qBAAqB,CAAC;AAmR7B;;;;;;;;;;;;GAYG;AACH,qBAAa,2BACX,YAAW,yBAAyB,CAAC,IAAI,CAAC;IAE1C,iBAAiB,EAAE,iBAAiB,CAAC;IACrC,mBAAmB,CAAC,EAAE,wBAAwB,GAAG,SAAS,CAAC;gBAGzD,iBAAiB,EAAE,iBAAiB,EACpC,mBAAmB,EAAE,wBAAwB,GAAG,SAAS;IAM3D,yCAAyC,CACvC,kBAAkB,EAAE,mCAAmC,GACtD,IAAI;IAwCP,qCAAqC,CACnC,kBAAkB,EAAE,+BAA+B,GAClD,IAAI;IAIP,yCAAyC,CACvC,kBAAkB,EAAE,mCAAmC,GACtD,IAAI;IAIP,2CAA2C,CACzC,kBAAkB,EAAE,qCAAqC,GACxD,IAAI;IAIP,4BAA4B,CAC1B,kBAAkB,EAAE,sBAAsB,GACzC,IAAI;IAIP,4BAA4B,CAC1B,kBAAkB,EAAE,sBAAsB,GACzC,IAAI;IAIP,0BAA0B,CAAC,kBAAkB,EAAE,oBAAoB,GAAG,IAAI;IAI1E,uBAAuB,CAAC,kBAAkB,EAAE,iBAAiB,GAAG,IAAI;IAIpE,0BAA0B,CAAC,kBAAkB,EAAE,oBAAoB,GAAG,IAAI;IAI1E,2BAA2B,CAAC,kBAAkB,EAAE,qBAAqB,GAAG,IAAI;IAI5E,6BAA6B,CAC3B,kBAAkB,EAAE,uBAAuB,GAC1C,IAAI;IAIP,wBAAwB,CAAC,kBAAkB,EAAE,kBAAkB,GAAG,IAAI;IAItE,+BAA+B,CAC7B,kBAAkB,EAAE,yBAAyB,GAC5C,IAAI;IAIP,8BAA8B,CAC5B,kBAAkB,EAAE,wBAAwB,GAC3C,IAAI;IA2nBP,wBAAwB,CAAC,kBAAkB,EAAE,kBAAkB,GAAG,IAAI;IAItE,iCAAiC,CAC/B,kBAAkB,EAAE,2BAA2B,GAC9C,IAAI;IAaP,gCAAgC,CAC9B,kBAAkB,EAAE,0BAA0B,GAC7C,IAAI;IAgFP,mBAAmB,CAAC,kBAAkB,EAAE,aAAa,GAAG,IAAI;CAG7D;AAED,eAAO,MAAM,sBAAsB,eACrB,kBAAkB,EAAE,qBACb,iBAAiB,KACnC,IAWF,CAAC;AAEF,eAAO,MAAM,iCAAiC,sBACzB,iBAAiB,cACxB,cAAc,KACzB,IAYF,CAAC"}

package/lib/stores/QueryBuilderValueSpecificationProcessor.js

@@ -1,548 +0,0 @@
-/**
- * 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, guaranteeNonNullable, guaranteeType, isNonNullable, isNumber, isString, returnUndefOnError, UnsupportedOperationError, } from '@finos/legend-shared';
-import { COLUMN_SORT_TYPE, SortColumnState, } from './fetch-structure/projection/QueryResultSetModifierState.js';
-import { QueryBuilderFilterTreeGroupNodeData, QueryBuilderFilterTreeConditionNodeData, } from './filter/QueryBuilderFilterState.js';
-import { FETCH_STRUCTURE_MODE } from './fetch-structure/QueryBuilderFetchStructureState.js';
-import { MILESTONING_STEREOTYPE, DerivedProperty, RawLambda, matchFunctionName, Class, CollectionInstanceValue, GraphFetchTreeInstanceValue, LambdaFunctionInstanceValue, PrimitiveInstanceValue, RootGraphFetchTree, SimpleFunctionExpression, VariableExpression, AbstractPropertyExpression, V1_deserializeRawValueSpecification, V1_RawLambda, getMilestoneTemporalStereotype, } from '@finos/legend-graph';
-import { QueryBuilderDerivationProjectionColumnState, QueryBuilderSimpleProjectionColumnState, } from './fetch-structure/projection/QueryBuilderProjectionColumnState.js';
-import { processPostFilterLambda } from './fetch-structure/projection/post-filter/QueryBuilderPostFilterValueSpecificationProcessor.js';
-import { getDerivedPropertyMilestoningSteoreotype } from './QueryBuilderPropertyEditorState.js';
-import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../QueryBuilder_Const.js';
-import { LambdaParameterState } from '@finos/legend-application';
-import { toGroupOperation } from './QueryBuilderGroupOperationHelper.js';
-const getNullableStringValueFromValueSpec = (valueSpec) => {
-    if (valueSpec instanceof PrimitiveInstanceValue &&
-        isString(valueSpec.values[0])) {
-        return valueSpec.values[0];
-    }
-    return undefined;
-};
-const getNullableNumberValueFromValueSpec = (valueSpec) => {
-    if (valueSpec instanceof PrimitiveInstanceValue &&
-        isNumber(valueSpec.values[0])) {
-        return valueSpec.values[0];
-    }
-    return undefined;
-};
-/**
- * Checks if the milestoning property expression is valid in terms of number of parameter values provided
- * in relation to its milestoning type.
- *
- * NOTE: this takes date propgation into account. See the table below for all
- * the combination:
- *
- *             | [source] |          |          |          |          |
- * ----------------------------------------------------------------------
- *   [target]  |          |   NONE   |  PR_TMP  |  BI_TMP  |  BU_TMP  |
- * ----------------------------------------------------------------------
- *             |   NONE   |   N.A.   |   PRD    | PRD,BUD  |    BUD   |
- * ----------------------------------------------------------------------
- *             |  PR_TMP  |   N.A.   |    X     | PRD,BUD  |    BUD   |
- * ----------------------------------------------------------------------
- *             |  BI_TMP  |   N.A.   |    X     |    X     |    X     |
- * ----------------------------------------------------------------------
- *             |  BU_TMP  |   N.A.   |   PRD    | PRD,BUD  |    X     |
- * ----------------------------------------------------------------------
- *
- * Annotations:
- *
- * [source]: source temporal type
- * [target]: target temporal type
- *
- * PR_TMP  : processing temporal
- * BI_TMP  : bitemporal
- * BU_TMP  : business temporal
- *
- * X       : no default date propagated
- * PRD     : default processing date is propagated
- * BUD     : default business date is propgated
- */
-const validatePropertyExpressionChain = (propertyExpression, graph) => {
-    if (propertyExpression.func.genericType.value.rawType instanceof Class &&
-        propertyExpression.func._OWNER._generatedMilestonedProperties.length !== 0) {
-        const name = propertyExpression.func.name;
-        const func = propertyExpression.func._OWNER._generatedMilestonedProperties.find((e) => e.name === name);
-        if (func) {
-            const targetStereotype = getMilestoneTemporalStereotype(propertyExpression.func.genericType.value.rawType, graph);
-            if (targetStereotype) {
-                const sourceStereotype = getDerivedPropertyMilestoningSteoreotype(guaranteeType(func, DerivedProperty), graph);
-                if (sourceStereotype !== MILESTONING_STEREOTYPE.BITEMPORAL &&
-                    targetStereotype !== sourceStereotype) {
-                    if (targetStereotype === MILESTONING_STEREOTYPE.BITEMPORAL) {
-                        if (propertyExpression.parametersValues.length !== 3 &&
-                            !sourceStereotype) {
-                            throw new UnsupportedOperationError(`Property of milestoning sterotype '${MILESTONING_STEREOTYPE.BITEMPORAL}' should have exactly two parameters`);
-                        }
-                        else if (propertyExpression.parametersValues.length < 2) {
-                            throw new UnsupportedOperationError(`Property of milestoning sterotype '${MILESTONING_STEREOTYPE.BITEMPORAL}' should have at least one parameter`);
-                        }
-                        else if (propertyExpression.parametersValues.length > 3) {
-                            throw new UnsupportedOperationError(`Property of milestoning sterotype '${MILESTONING_STEREOTYPE.BITEMPORAL}' should not have more than two parameters`);
-                        }
-                    }
-                    else if (propertyExpression.parametersValues.length !== 2) {
-                        throw new UnsupportedOperationError(`Property of milestoning sterotype '${targetStereotype}' should have exactly one parameter`);
-                    }
-                }
-            }
-        }
-    }
-};
-const processFilterExpression = (expression, filterState, parentFilterNodeId) => {
-    const parentNode = parentFilterNodeId
-        ? filterState.getNode(parentFilterNodeId)
-        : undefined;
-    if ([
-        QUERY_BUILDER_SUPPORTED_FUNCTIONS.AND,
-        QUERY_BUILDER_SUPPORTED_FUNCTIONS.OR,
-    ].some((fn) => matchFunctionName(expression.functionName, fn))) {
-        const groupNode = new QueryBuilderFilterTreeGroupNodeData(parentFilterNodeId, toGroupOperation(expression.functionName));
-        filterState.nodes.set(groupNode.id, groupNode);
-        expression.parametersValues.forEach((filterExpression) => processFilterExpression(guaranteeType(filterExpression, SimpleFunctionExpression, `Can't process filter group expression: each child expression must be a function expression`), filterState, groupNode.id));
-        filterState.addNodeFromNode(groupNode, parentNode);
-    }
-    else {
-        const propertyExpression = expression.parametersValues[0];
-        if (propertyExpression instanceof AbstractPropertyExpression) {
-            const currentPropertyExpression = propertyExpression.parametersValues[0];
-            if (currentPropertyExpression instanceof AbstractPropertyExpression) {
-                validatePropertyExpressionChain(currentPropertyExpression, filterState.queryBuilderState.graphManagerState.graph);
-            }
-        }
-        for (const operator of filterState.operators) {
-            // NOTE: this allow plugin author to either return `undefined` or throw error
-            // if there is a problem with building the lambda. Either case, the plugin is
-            // considered as not supporting the lambda.
-            const filterConditionState = returnUndefOnError(() => operator.buildFilterConditionState(filterState, expression));
-            if (filterConditionState) {
-                filterState.addNodeFromNode(new QueryBuilderFilterTreeConditionNodeData(undefined, filterConditionState), parentNode);
-                return;
-            }
-        }
-        throw new UnsupportedOperationError(`Can't process filter() expression: no compatible filter operator processer available from plugins`);
-    }
-};
-const processFilterLambda = (filterLambda, filterState) => {
-    const lambdaFunc = guaranteeNonNullable(filterLambda.values[0], `Can't process filter() lambda: filter() lambda function is missing`);
-    assertTrue(lambdaFunc.expressionSequence.length === 1, `Can't process filter() lambda: only support filter() lambda body with 1 expression`);
-    const rootExpression = guaranteeType(lambdaFunc.expressionSequence[0], SimpleFunctionExpression, `Can't process filter() lambda: only support filter() lambda body with 1 expression`);
-    assertTrue(lambdaFunc.functionType.parameters.length === 1, `Can't process filter() lambda: only support filter() lambda with 1 parameter`);
-    filterState.setLambdaParameterName(guaranteeType(lambdaFunc.functionType.parameters[0], VariableExpression, `Can't process filter() lambda: only support filter() lambda with 1 parameter`).name);
-    processFilterExpression(rootExpression, filterState, undefined);
-};
-const processAggregateLambda = (aggregateLambda, projectionColumnState, aggregationState) => {
-    const lambdaFunc = guaranteeNonNullable(aggregateLambda.values[0], `Can't process agg() lambda: agg() lambda function is missing`);
-    assertTrue(lambdaFunc.expressionSequence.length === 1, `Can't process agg() lambda: only support agg() lambda body with 1 expression`);
-    const expression = guaranteeType(lambdaFunc.expressionSequence[0], SimpleFunctionExpression, `Can't process agg() lambda: only support agg() lambda body with 1 expression`);
-    assertTrue(lambdaFunc.functionType.parameters.length === 1, `Can't process agg() lambda: only support agg() lambda with 1 parameter`);
-    const lambdaParam = guaranteeType(lambdaFunc.functionType.parameters[0], VariableExpression, `Can't process agg() lambda: only support agg() lambda with 1 parameter`);
-    for (const operator of aggregationState.operators) {
-        // NOTE: this allow plugin author to either return `undefined` or throw error
-        // if there is a problem with building the lambda. Either case, the plugin is
-        // considered as not supporting the lambda.
-        const aggregateColumnState = returnUndefOnError(() => operator.buildAggregateColumnState(expression, lambdaParam, projectionColumnState));
-        if (aggregateColumnState) {
-            aggregationState.addColumn(aggregateColumnState);
-            return;
-        }
-    }
-    throw new UnsupportedOperationError(`Can't process aggregate expression function: no compatible aggregate operator processer available from plugins`);
-};
-/**
- * This is the expression processor for query builder.
- * Unlike expression builder which takes care of transforming the value specification
- * from `protocol` to `metamodel`, and type-inferencing, this takes care
- * of traversing the expression to populate the query builder UI state.
- *
- * NOTE: While traversing the expression, this processor also does a fair amount of
- * validations and assertsions but just so enough to populate the UI state.
- *
- * Validation and assertion should be done by both the builder and processor, but the builder
- * will do more structural checks to build the proper metamodel. The processor should never
- * modify the metamodel, just traversing it.
- */
-export class QueryBuilderLambdaProcessor {
-    queryBuilderState;
-    precedingExpression;
-    constructor(queryBuilderState, precedingExpression) {
-        this.queryBuilderState = queryBuilderState;
-        this.precedingExpression = precedingExpression;
-    }
-    visit_INTERNAL__UnknownValueSpecification(valueSpecification) {
-        assertNonNullable(this.precedingExpression, `Can't process unknown value: unknown value preceding expression cannot be retrieved`);
-        const precedingExpressionName = this.precedingExpression.functionName;
-        if ([
-            QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_PROJECT,
-            QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_GROUP_BY,
-            QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_AGG,
-        ].some((fn) => matchFunctionName(precedingExpressionName, fn))) {
-            const projectionState = this.queryBuilderState.fetchStructureState.projectionState;
-            const rawLambdaProtocol = returnUndefOnError(() => guaranteeType(V1_deserializeRawValueSpecification(valueSpecification.content), V1_RawLambda));
-            assertNonNullable(rawLambdaProtocol, `Can't process unknown value: only support ${precedingExpressionName}() column expression as a lambda`);
-            const columnState = new QueryBuilderDerivationProjectionColumnState(projectionState, new RawLambda(rawLambdaProtocol.parameters, rawLambdaProtocol.body));
-            projectionState.addColumn(columnState, { skipSorting: true });
-            return;
-        }
-        throw new UnsupportedOperationError(`Can't process unknown value with preceding expression of function ${this.precedingExpression.functionName}()`);
-    }
-    visit_RootGraphFetchTreeInstanceValue(valueSpecification) {
-        throw new UnsupportedOperationError();
-    }
-    visit_PropertyGraphFetchTreeInstanceValue(valueSpecification) {
-        throw new UnsupportedOperationError();
-    }
-    visit_AlloySerializationConfigInstanceValue(valueSpecification) {
-        throw new UnsupportedOperationError();
-    }
-    visit_PrimitiveInstanceValue(valueSpecification) {
-        throw new UnsupportedOperationError();
-    }
-    visit_EnumValueInstanceValue(valueSpecification) {
-        throw new UnsupportedOperationError();
-    }
-    visit_RuntimeInstanceValue(valueSpecification) {
-        throw new UnsupportedOperationError();
-    }
-    visit_PairInstanceValue(valueSpecification) {
-        throw new UnsupportedOperationError();
-    }
-    visit_MappingInstanceValue(valueSpecification) {
-        throw new UnsupportedOperationError();
-    }
-    visit_PureListInstanceValue(valueSpecification) {
-        throw new UnsupportedOperationError();
-    }
-    visit_CollectionInstanceValue(valueSpecification) {
-        throw new UnsupportedOperationError();
-    }
-    visit_FunctionExpression(valueSpecification) {
-        throw new UnsupportedOperationError();
-    }
-    visit_INTERNAL__PropagatedValue(valueSpecification) {
-        throw new UnsupportedOperationError();
-    }
-    visit_SimpleFunctionExpression(valueSpecification) {
-        const functionName = valueSpecification.functionName;
-        if (matchFunctionName(functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.GET_ALL)) {
-            const _class = valueSpecification.genericType?.value.rawType;
-            assertType(_class, Class, `Can't process getAll() expression: getAll() return type is missing`);
-            this.queryBuilderState.querySetupState.setClass(_class, true);
-            this.queryBuilderState.explorerState.refreshTreeData();
-            let acceptedNoOfParameters = 1;
-            const stereotype = getMilestoneTemporalStereotype(_class, this.queryBuilderState.graphManagerState.graph);
-            switch (stereotype) {
-                case MILESTONING_STEREOTYPE.BITEMPORAL:
-                    acceptedNoOfParameters = 3;
-                    assertTrue(valueSpecification.parametersValues.length ===
-                        acceptedNoOfParameters, `Can't process getAll() expression: when used with a bitemporal milestoned class getAll() expects two parameters`);
-                    this.queryBuilderState.querySetupState.setProcessingDate(valueSpecification.parametersValues[1]);
-                    this.queryBuilderState.querySetupState.setBusinessDate(valueSpecification.parametersValues[2]);
-                    break;
-                case MILESTONING_STEREOTYPE.BUSINESS_TEMPORAL:
-                    acceptedNoOfParameters = 2;
-                    assertTrue(valueSpecification.parametersValues.length ===
-                        acceptedNoOfParameters, `Can't process getAll() expression: when used with a milestoned class getAll() expects a parameter`);
-                    this.queryBuilderState.querySetupState.setBusinessDate(valueSpecification.parametersValues[1]);
-                    break;
-                case MILESTONING_STEREOTYPE.PROCESSING_TEMPORAL:
-                    acceptedNoOfParameters = 2;
-                    assertTrue(valueSpecification.parametersValues.length ===
-                        acceptedNoOfParameters, `Can't process getAll() expression: when used with a milestoned class getAll() expects a parameter`);
-                    this.queryBuilderState.querySetupState.setProcessingDate(valueSpecification.parametersValues[1]);
-                    break;
-                default:
-                    assertTrue(valueSpecification.parametersValues.length ===
-                        acceptedNoOfParameters, `Can't process getAll() expression: getAll() expects no arguments`);
-            }
-            return;
-        }
-        else if (matchFunctionName(functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.FILTER) ||
-            matchFunctionName(functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_FILTER)) {
-            assertTrue(valueSpecification.parametersValues.length === 2, `Can't process filter() expression: filter() expects 1 argument`);
-            const filterState = this.queryBuilderState.filterState;
-            const precedingExpression = guaranteeType(valueSpecification.parametersValues[0], SimpleFunctionExpression, `Can't process filter() expression: only support filter() immediately following an expression`);
-            precedingExpression.accept_ValueSpecificationVisitor(new QueryBuilderLambdaProcessor(this.queryBuilderState, undefined));
-            if (matchFunctionName(precedingExpression.functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.GET_ALL)) {
-                assertTrue(matchFunctionName(functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.FILTER), `Can't process filter() expression: only supports ${QUERY_BUILDER_SUPPORTED_FUNCTIONS.FILTER}() immediately following getAll() (got '${functionName}')`);
-                const filterLambda = valueSpecification.parametersValues[1];
-                assertType(filterLambda, LambdaFunctionInstanceValue, `Can't process filter() expression: filter() expects argument #1 to be a lambda function`);
-                processFilterLambda(filterLambda, filterState);
-                /**
-                 * NOTE: Since group operations like and/or do not take more than 2 parameters, if there are
-                 * more than 2 clauses in each group operations, then these clauses are converted into an
-                 * unbalanced tree. However, this would look quite bad for UX, as such, we simplify the tree.
-                 * After building the filter state.
-                 */
-                filterState.simplifyTree();
-                return;
-            }
-            else if (matchFunctionName(precedingExpression.functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_PROJECT) ||
-                matchFunctionName(precedingExpression.functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_GROUP_BY)) {
-                assertTrue(matchFunctionName(functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_FILTER), `Can't process post-filter expression: only supports ${QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_FILTER}() immediately following TDS project()/groupBy() (got '${functionName}')`);
-                const postFilterState = this.queryBuilderState.fetchStructureState.projectionState
-                    .postFilterState;
-                const postFilterLambda = valueSpecification.parametersValues[1];
-                assertType(postFilterLambda, LambdaFunctionInstanceValue, `Can't process post-filter expression: expects argument #1 to be a lambda function`);
-                processPostFilterLambda(postFilterLambda, postFilterState);
-                this.queryBuilderState.fetchStructureState.projectionState.setShowPostFilterPanel(true);
-                postFilterState.simplifyTree();
-                return;
-            }
-            else {
-                throw new UnsupportedOperationError("`Can't process filter() expression: only support filter() immediately following getAll() or TDS project()/groupBy()");
-            }
-        }
-        else if (matchFunctionName(functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_PROJECT)) {
-            const params = valueSpecification.parametersValues;
-            assertTrue(params.length === 3, `Can't process project() expression: project() expects 2 arguments`);
-            const precedingExpression = guaranteeType(params[0], SimpleFunctionExpression, `Can't process project() expression: only support project() immediately following an expression`);
-            precedingExpression.accept_ValueSpecificationVisitor(new QueryBuilderLambdaProcessor(this.queryBuilderState, undefined));
-            // check caller
-            assertTrue([
-                QUERY_BUILDER_SUPPORTED_FUNCTIONS.GET_ALL,
-                QUERY_BUILDER_SUPPORTED_FUNCTIONS.FILTER,
-            ].some((fn) => matchFunctionName(precedingExpression.functionName, fn)), `Can't process project() expression: only support project() immediately following either getAll() or filter()`);
-            // columns
-            const columnLambdas = params[1];
-            assertType(columnLambdas, CollectionInstanceValue, `Can't process project() expression: project() expects argument #1 to be a collection`);
-            columnLambdas.values.map((value) => value.accept_ValueSpecificationVisitor(new QueryBuilderLambdaProcessor(this.queryBuilderState, valueSpecification)));
-            // aliases
-            const columnAliases = params[2];
-            assertType(columnAliases, CollectionInstanceValue, `Can't process project() expression: project() expects argument #2 to be a collection`);
-            assertTrue(columnLambdas.values.length === columnAliases.values.length, `Can't process project() expression: number of aliases does not match the number of columns`);
-            const aliases = columnAliases.values
-                .map(getNullableStringValueFromValueSpec)
-                .filter(isNonNullable);
-            this.queryBuilderState.fetchStructureState.projectionState.columns.forEach((e, idx) => e.setColumnName(aliases[idx]));
-            this.queryBuilderState.fetchStructureState.setFetchStructureMode(FETCH_STRUCTURE_MODE.PROJECTION);
-            return;
-        }
-        else if (matchFunctionName(functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_TAKE)) {
-            assertTrue(valueSpecification.parametersValues.length === 2, `Can't process take() expression: take() expects 1 argument`);
-            const precedingExpression = guaranteeType(valueSpecification.parametersValues[0], SimpleFunctionExpression, `Can't process take() expression: only support take() immediately following an expression`);
-            precedingExpression.accept_ValueSpecificationVisitor(new QueryBuilderLambdaProcessor(this.queryBuilderState, undefined));
-            // check caller
-            assertTrue([
-                QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_TAKE,
-                QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_DISTINCT,
-                QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_SORT,
-                QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_PROJECT,
-                QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_GROUP_BY,
-            ].some((fn) => matchFunctionName(precedingExpression.functionName, fn)), `Can't process take() expression: only support take() in TDS expression`);
-            const takeValue = getNullableNumberValueFromValueSpec(guaranteeNonNullable(valueSpecification.parametersValues[1]));
-            this.queryBuilderState.fetchStructureState.projectionState.resultSetModifierState.setLimit(takeValue);
-            return;
-        }
-        else if (matchFunctionName(functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_DISTINCT)) {
-            assertTrue(valueSpecification.parametersValues.length === 1, `Can't process disctinct() expression: distinct() expects no parameter`);
-            const precedingExpression = guaranteeType(valueSpecification.parametersValues[0], SimpleFunctionExpression, `Can't process distinct() expression: only support distinct() immediately following an expression`);
-            precedingExpression.accept_ValueSpecificationVisitor(new QueryBuilderLambdaProcessor(this.queryBuilderState, undefined));
-            // check caller
-            assertTrue([
-                QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_TAKE,
-                QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_DISTINCT,
-                QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_SORT,
-                QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_PROJECT,
-                QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_GROUP_BY,
-                QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_FILTER,
-            ].some((fn) => matchFunctionName(precedingExpression.functionName, fn)), `Can't process distinct() expression: only support distinct() in TDS expression`);
-            this.queryBuilderState.fetchStructureState.projectionState.resultSetModifierState.distinct =
-                true;
-            return;
-        }
-        else if (matchFunctionName(functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_SORT)) {
-            assertTrue(valueSpecification.parametersValues.length === 2, `Can't process sort() expression: sort() expects 1 argument`);
-            const precedingExpression = guaranteeType(valueSpecification.parametersValues[0], SimpleFunctionExpression, `Can't process sort() expression: only support sort() immediately following an expression`);
-            precedingExpression.accept_ValueSpecificationVisitor(new QueryBuilderLambdaProcessor(this.queryBuilderState, undefined));
-            // check caller
-            assertTrue([
-                QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_TAKE,
-                QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_DISTINCT,
-                QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_SORT,
-                QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_PROJECT,
-                QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_GROUP_BY,
-                QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_FILTER,
-            ].some((fn) => matchFunctionName(precedingExpression.functionName, fn)), `Can't process sort() expression: only support sort() in TDS expression`);
-            const sortParam = valueSpecification.parametersValues[1];
-            assertType(sortParam, CollectionInstanceValue, `Can't process sort() expression: sort() argument should be a collection`);
-            sortParam.values.map((e) => e.accept_ValueSpecificationVisitor(new QueryBuilderLambdaProcessor(this.queryBuilderState, valueSpecification)));
-            return;
-        }
-        else if ((matchFunctionName(functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_ASC) ||
-            matchFunctionName(functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_DESC)) &&
-            this.precedingExpression &&
-            matchFunctionName(this.precedingExpression.functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_SORT)) {
-            assertTrue(valueSpecification.parametersValues.length === 1, `Can't process ${functionName}() expression: ${functionName}() expects no argument`);
-            const sortColumnName = getNullableStringValueFromValueSpec(guaranteeNonNullable(valueSpecification.parametersValues[0]));
-            const queryBuilderProjectionColumnState = this.queryBuilderState.fetchStructureState.projectionState.columns.find((e) => e.columnName === sortColumnName);
-            if (queryBuilderProjectionColumnState) {
-                const sortColumnState = new SortColumnState(queryBuilderProjectionColumnState);
-                sortColumnState.sortType = matchFunctionName(functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_ASC)
-                    ? COLUMN_SORT_TYPE.ASC
-                    : COLUMN_SORT_TYPE.DESC;
-                this.queryBuilderState.fetchStructureState.projectionState.resultSetModifierState.addSortColumn(sortColumnState);
-            }
-            return;
-        }
-        else if (matchFunctionName(functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_GROUP_BY)) {
-            assertTrue(valueSpecification.parametersValues.length === 4, `Can't process groupBy() expression: groupBy() expects 3 arguments`);
-            const params = valueSpecification.parametersValues;
-            const precedingExpression = guaranteeType(params[0], SimpleFunctionExpression, `Can't process groupBy() expression: only support groupBy() immediately following an expression`);
-            precedingExpression.accept_ValueSpecificationVisitor(new QueryBuilderLambdaProcessor(this.queryBuilderState, undefined));
-            // check caller
-            assertTrue([
-                QUERY_BUILDER_SUPPORTED_FUNCTIONS.GET_ALL,
-                QUERY_BUILDER_SUPPORTED_FUNCTIONS.FILTER,
-            ].some((fn) => matchFunctionName(precedingExpression.functionName, fn)), `Can't process groupBy() expression: only support groupBy() immediately following either getAll() or filter()`);
-            // columns
-            const columnExpressions = params[1];
-            assertType(columnExpressions, CollectionInstanceValue, `Can't process groupBy() expression: groupBy() expects argument #1 to be a collection`);
-            columnExpressions.values.map((e) => e.accept_ValueSpecificationVisitor(new QueryBuilderLambdaProcessor(this.queryBuilderState, valueSpecification)));
-            // aggregations
-            const aggregationExpressions = params[2];
-            assertType(aggregationExpressions, CollectionInstanceValue, `Can't process groupBy() expression: groupBy() expects argument #2 to be a collection`);
-            aggregationExpressions.values.map((e) => e.accept_ValueSpecificationVisitor(new QueryBuilderLambdaProcessor(this.queryBuilderState, valueSpecification)));
-            // aliases
-            const columnAliases = params[3];
-            assertType(columnAliases, CollectionInstanceValue, `Can't process groupBy() expression: groupBy() expects argument #3 to be a collection`);
-            assertTrue(columnAliases.values.length ===
-                columnExpressions.values.length +
-                    aggregationExpressions.values.length, `Can't process groupBy() expression: number of aliases does not match the number of columns`);
-            const aliases = columnAliases.values
-                .map(getNullableStringValueFromValueSpec)
-                .filter(isNonNullable);
-            this.queryBuilderState.fetchStructureState.projectionState.columns.forEach((e, idx) => e.setColumnName(aliases[idx]));
-            this.queryBuilderState.fetchStructureState.setFetchStructureMode(FETCH_STRUCTURE_MODE.PROJECTION);
-            return;
-        }
-        else if (matchFunctionName(functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_AGG)) {
-            assertTrue(valueSpecification.parametersValues.length === 2, `Can't process agg() expression: agg() expects 2 arguments`);
-            // check caller
-            assertNonNullable(this.precedingExpression);
-            assertTrue(matchFunctionName(this.precedingExpression.functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_GROUP_BY), `Can't process agg() expression: only support agg() in aggregation`);
-            const columnLambdas = guaranteeNonNullable(valueSpecification.parametersValues[0]);
-            columnLambdas.accept_ValueSpecificationVisitor(new QueryBuilderLambdaProcessor(this.queryBuilderState, valueSpecification));
-            const aggregateLambda = valueSpecification.parametersValues[1];
-            assertType(aggregateLambda, LambdaFunctionInstanceValue, `Can't process agg() expression: agg() expects argument #1 to be a lambda function`);
-            // NOTE: since we process agg() expressions one by one, we know that the current agg()
-            // always correspond to the last column projection state, based on our processing procedure
-            processAggregateLambda(aggregateLambda, guaranteeNonNullable(this.queryBuilderState.fetchStructureState.projectionState.columns[this.queryBuilderState.fetchStructureState.projectionState.columns
-                .length - 1]), this.queryBuilderState.fetchStructureState.projectionState
-                .aggregationState);
-            return;
-        }
-        else if (matchFunctionName(functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.SERIALIZE)) {
-            assertTrue(valueSpecification.parametersValues.length === 2, `Can't process serialize() expression: serialize() expects 1 argument`);
-            const precedingExpression = guaranteeType(valueSpecification.parametersValues[0], SimpleFunctionExpression, `Can't process serialize() expression: only support serialize() immediately following an expression`);
-            precedingExpression.accept_ValueSpecificationVisitor(new QueryBuilderLambdaProcessor(this.queryBuilderState, valueSpecification));
-            // check caller
-            assertTrue([
-                QUERY_BUILDER_SUPPORTED_FUNCTIONS.GRAPH_FETCH,
-                QUERY_BUILDER_SUPPORTED_FUNCTIONS.GRAPH_FETCH_CHECKED,
-            ].some((fn) => matchFunctionName(precedingExpression.functionName, fn)), `Can't process serialize() expression: only support serialize() in graph-fetch expression`);
-            const serializeFunc = guaranteeType(valueSpecification.parametersValues[1], GraphFetchTreeInstanceValue, `Can't process serialize() expression: serialize() graph-fetch is missing`);
-            const value = guaranteeType(serializeFunc.values[0], RootGraphFetchTree, `Can't process serialize() expression: serialize() graph-fetch tree root is missing`);
-            this.queryBuilderState.fetchStructureState.setFetchStructureMode(FETCH_STRUCTURE_MODE.GRAPH_FETCH);
-            this.queryBuilderState.fetchStructureState.graphFetchTreeState.initialize(value);
-            return;
-        }
-        else if ((matchFunctionName(functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.GRAPH_FETCH_CHECKED) ||
-            matchFunctionName(functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.GRAPH_FETCH)) &&
-            this.precedingExpression &&
-            matchFunctionName(this.precedingExpression.functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.SERIALIZE)) {
-            assertTrue(valueSpecification.parametersValues.length === 2, `Can't process ${functionName}() expression: ${functionName}() expects 1 argument`);
-            const precedingExpression = guaranteeType(valueSpecification.parametersValues[0], SimpleFunctionExpression, `Can't process ${functionName}() expression: only support ${functionName}() immediately following an expression`);
-            precedingExpression.accept_ValueSpecificationVisitor(new QueryBuilderLambdaProcessor(this.queryBuilderState, valueSpecification));
-            // check caller
-            assertTrue([
-                QUERY_BUILDER_SUPPORTED_FUNCTIONS.FILTER,
-                QUERY_BUILDER_SUPPORTED_FUNCTIONS.GET_ALL,
-            ].some((fn) => matchFunctionName(precedingExpression.functionName, fn)), `Can't process ${functionName}(): only support ${functionName}() immediately following either getAll() or filter()`);
-            this.queryBuilderState.fetchStructureState.graphFetchTreeState.setChecked(matchFunctionName(functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.GRAPH_FETCH_CHECKED));
-            return;
-        }
-        throw new UnsupportedOperationError(`Can't process expression of function ${functionName}()`);
-    }
-    visit_VariableExpression(valueSpecification) {
-        throw new UnsupportedOperationError();
-    }
-    visit_LambdaFunctionInstanceValue(valueSpecification) {
-        valueSpecification.values.forEach((value) => value.expressionSequence.forEach((expression) => expression.accept_ValueSpecificationVisitor(new QueryBuilderLambdaProcessor(this.queryBuilderState, this.precedingExpression))));
-    }
-    visit_AbstractPropertyExpression(valueSpecification) {
-        assertNonNullable(this.precedingExpression, `Can't process property expression: property expression preceding expression cannot be retrieved`);
-        const precedingExpressionName = this.precedingExpression.functionName;
-        if ([
-            QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_PROJECT,
-            QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_GROUP_BY,
-            QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_AGG,
-        ].some((fn) => matchFunctionName(precedingExpressionName, fn))) {
-            // NOTE: we do this before creating the projection state, as we will
-            // auto-fill arguments for derived properties when missing as part of building
-            // the property expression state.
-            let currentPropertyExpression = valueSpecification;
-            while (currentPropertyExpression instanceof AbstractPropertyExpression) {
-                const propertyExpression = currentPropertyExpression;
-                validatePropertyExpressionChain(currentPropertyExpression, this.queryBuilderState.graphManagerState.graph);
-                currentPropertyExpression = guaranteeNonNullable(currentPropertyExpression.parametersValues[0]);
-                // here we just do a simple check to ensure that if we encounter derived properties
-                // the number of parameters and arguments provided match
-                if (propertyExpression.func instanceof DerivedProperty) {
-                    assertTrue((Array.isArray(propertyExpression.func.parameters)
-                        ? propertyExpression.func.parameters.length
-                        : 0) ===
-                        propertyExpression.parametersValues.length - 1, `Can't process property expression: derived property '${propertyExpression.func.name}' expects number of provided arguments to match number of parameters`);
-                }
-                // 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 SimpleFunctionExpression &&
-                    matchFunctionName(currentPropertyExpression.functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.SUBTYPE)) {
-                    currentPropertyExpression = guaranteeNonNullable(currentPropertyExpression.parametersValues[0]);
-                }
-            }
-            assertType(currentPropertyExpression, VariableExpression, `Can't process property expression: expects expression root to be a variable`);
-            const projectionState = this.queryBuilderState.fetchStructureState.projectionState;
-            const columnState = new QueryBuilderSimpleProjectionColumnState(projectionState, valueSpecification, false);
-            projectionState.addColumn(columnState, { skipSorting: true });
-            // NOTE: technically we should set the lambda parameter name when we process
-            // the lambda, not when we process the lambda body like this, but that requires
-            // some setup, so it's easier to do it here. The validation of this should have
-            // already been taken care of by the builder.
-            columnState.setLambdaParameterName(currentPropertyExpression.name);
-            return;
-        }
-        throw new UnsupportedOperationError(`Can't process property expression with preceding expression of function ${this.precedingExpression.functionName}()`);
-    }
-    visit_InstanceValue(valueSpecification) {
-        throw new UnsupportedOperationError();
-    }
-}
-export const processQueryParameters = (parameters, queryBuilderState) => {
-    const queryParameterState = queryBuilderState.queryParametersState;
-    parameters.forEach((parameter) => {
-        const parameterState = new LambdaParameterState(parameter, queryBuilderState.observableContext, queryBuilderState.graphManagerState.graph);
-        parameterState.mockParameterValue();
-        queryParameterState.addParameter(parameterState);
-    });
-};
-export const processQueryBuilderLambdaFunction = (queryBuilderState, lambdaFunc) => {
-    if (lambdaFunc.functionType.parameters.length) {
-        processQueryParameters(lambdaFunc.functionType.parameters, queryBuilderState);
-    }
-    lambdaFunc.expressionSequence.map((e) => e.accept_ValueSpecificationVisitor(new QueryBuilderLambdaProcessor(queryBuilderState, undefined)));
-};
-//# sourceMappingURL=QueryBuilderValueSpecificationProcessor.js.map