@finos/legend-application-query 6.0.0 → 7.0.1

package/src/stores/query-builder/QueryBuilderTextEditorState.ts

@@ -1,203 +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 {
-  GRAPH_MANAGER_EVENT,
-  buildSourceInformationSourceId,
-  ParserError,
-  RawLambda,
-  stub_RawLambda,
-  pruneSourceInformation,
-} from '@finos/legend-graph';
-import {
-  type GeneratorFn,
-  assertErrorThrown,
-  LogEvent,
-} from '@finos/legend-shared';
-import { observable, action, flow, makeObservable, flowResult } from 'mobx';
-import type { QueryBuilderState } from './QueryBuilderState.js';
-import { LambdaEditorState, TAB_SIZE } from '@finos/legend-application';
-
-export class QueryBuilderRawLambdaState {
-  lambda: RawLambda;
-
-  constructor(lambda: RawLambda) {
-    this.lambda = lambda;
-
-    makeObservable(this, {
-      lambda: observable,
-      setLambda: action,
-    });
-  }
-
-  setLambda(lambda: RawLambda): void {
-    this.lambda = lambda;
-  }
-}
-
-export enum QueryBuilderTextEditorMode {
-  TEXT = 'TEXT',
-  JSON = 'JSON',
-}
-
-export class QueryBuilderTextEditorState extends LambdaEditorState {
-  queryBuilderState: QueryBuilderState;
-  rawLambdaState: QueryBuilderRawLambdaState;
-  isConvertingLambdaToString = false;
-  mode: QueryBuilderTextEditorMode | undefined;
-  /**
-   * This is used to store the JSON string when viewing the query in JSON mode
-   * TODO: consider moving this to another state if we need to simplify the logic of text-mode
-   */
-  readOnlylambdaJson = '';
-
-  constructor(queryBuilderState: QueryBuilderState) {
-    super('', '');
-
-    makeObservable(this, {
-      rawLambdaState: observable,
-      isConvertingLambdaToString: observable,
-      mode: observable,
-      setQueryRawLambdaState: action,
-      setMode: action,
-      openModal: action,
-      closeModal: flow,
-    });
-
-    this.queryBuilderState = queryBuilderState;
-    this.rawLambdaState = new QueryBuilderRawLambdaState(stub_RawLambda());
-  }
-
-  get lambdaId(): string {
-    return buildSourceInformationSourceId(['query-builder']);
-  }
-
-  setQueryRawLambdaState(rawLambdaState: QueryBuilderRawLambdaState): void {
-    this.rawLambdaState = rawLambdaState;
-  }
-
-  setMode(openModal: QueryBuilderTextEditorMode | undefined): void {
-    this.mode = openModal;
-  }
-
-  setLambdaJson(lambdaJson: string): void {
-    this.readOnlylambdaJson = lambdaJson;
-  }
-
-  *convertLambdaGrammarStringToObject(): GeneratorFn<void> {
-    const emptyLambda = stub_RawLambda();
-    if (this.lambdaString) {
-      try {
-        const lambda =
-          (yield this.queryBuilderState.graphManagerState.graphManager.pureCodeToLambda(
-            this.fullLambdaString,
-            this.lambdaId,
-            { pruneSourceInformation: true },
-          )) as RawLambda;
-        this.setParserError(undefined);
-        this.rawLambdaState.setLambda(lambda);
-      } catch (error) {
-        assertErrorThrown(error);
-        if (error instanceof ParserError) {
-          this.setParserError(error);
-        }
-        this.queryBuilderState.applicationStore.log.error(
-          LogEvent.create(GRAPH_MANAGER_EVENT.PARSING_FAILURE),
-          error,
-        );
-      }
-    } else {
-      this.clearErrors();
-      this.rawLambdaState.setLambda(emptyLambda);
-    }
-  }
-
-  *convertLambdaObjectToGrammarString(pretty: boolean): GeneratorFn<void> {
-    if (this.rawLambdaState.lambda.body) {
-      this.isConvertingLambdaToString = true;
-      try {
-        const lambdas = new Map<string, RawLambda>();
-        lambdas.set(
-          this.lambdaId,
-          new RawLambda(
-            this.rawLambdaState.lambda.parameters,
-            this.rawLambdaState.lambda.body,
-          ),
-        );
-        const isolatedLambdas =
-          (yield this.queryBuilderState.graphManagerState.graphManager.lambdasToPureCode(
-            lambdas,
-            pretty,
-          )) as Map<string, string>;
-        const grammarText = isolatedLambdas.get(this.lambdaId);
-        this.setLambdaString(
-          grammarText !== undefined
-            ? this.extractLambdaString(grammarText)
-            : '',
-        );
-        this.clearErrors();
-        this.isConvertingLambdaToString = false;
-      } catch (error) {
-        assertErrorThrown(error);
-        this.queryBuilderState.applicationStore.log.error(
-          LogEvent.create(GRAPH_MANAGER_EVENT.PARSING_FAILURE),
-          error,
-        );
-        this.isConvertingLambdaToString = false;
-      }
-    } else {
-      this.clearErrors();
-      this.setLambdaString('');
-    }
-  }
-
-  openModal(mode: QueryBuilderTextEditorMode): void {
-    const rawLambda = this.queryBuilderState.buildQuery();
-    if (mode === QueryBuilderTextEditorMode.TEXT) {
-      this.setQueryRawLambdaState(new QueryBuilderRawLambdaState(rawLambda));
-    }
-    if (mode === QueryBuilderTextEditorMode.JSON) {
-      this.setLambdaJson(
-        JSON.stringify(
-          pruneSourceInformation(
-            this.queryBuilderState.graphManagerState.graphManager.serializeRawValueSpecification(
-              rawLambda,
-            ),
-          ),
-          null,
-          TAB_SIZE,
-        ),
-      );
-    }
-    this.setMode(mode);
-  }
-
-  *closeModal(): GeneratorFn<void> {
-    if (this.mode === QueryBuilderTextEditorMode.TEXT) {
-      yield flowResult(this.convertLambdaGrammarStringToObject());
-      if (this.parserError) {
-        this.queryBuilderState.applicationStore.notifyError(
-          `Can't parse query. Please fix error before closing: ${this.parserError.message}`,
-        );
-      } else {
-        this.queryBuilderState.initialize(this.rawLambdaState.lambda);
-        this.setMode(undefined);
-      }
-      return;
-    }
-    this.setMode(undefined);
-  }
-}

package/src/stores/query-builder/QueryBuilderTypeaheadHelper.ts

@@ -1,152 +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 AbstractPropertyExpression,
-  type ExecutionResult,
-  type ValueSpecification,
-  PrimitiveInstanceValue,
-  PRIMITIVE_TYPE,
-  TdsExecutionResult,
-  type RawLambda,
-} from '@finos/legend-graph';
-import { guaranteeType, isNonNullable, isString } from '@finos/legend-shared';
-import { QueryBuilderPostFilterOperator_StartWith } from './fetch-structure/projection/post-filter/operators/QueryBuilderPostFilterOperator_StartWith.js';
-import type { QueryBuilderAggregateColumnState } from './fetch-structure/projection/aggregation/QueryBuilderAggregationState.js';
-import {
-  PostFilterConditionState,
-  QueryBuilderPostFilterTreeConditionNodeData,
-} from './fetch-structure/projection/post-filter/QueryBuilderPostFilterState.js';
-import {
-  QueryBuilderProjectionColumnState,
-  QueryBuilderSimpleProjectionColumnState,
-} from './fetch-structure/projection/QueryBuilderProjectionColumnState.js';
-import type { QueryBuilderState } from './QueryBuilderState.js';
-import { QueryBuilderProjectionState } from './fetch-structure/projection/QueryBuilderProjectionState.js';
-
-const TYPEAHEAD_TAKE_LIMIT = 10;
-const START_LENGTH = 3;
-
-const initializeQueryBuilderState = (
-  queryBuilderState: QueryBuilderState,
-): QueryBuilderState => {
-  const builderState = queryBuilderState.INTERNAL__toBasicQueryBuilderState();
-  const projectionState = guaranteeType(
-    builderState.fetchStructureState.implementation,
-    QueryBuilderProjectionState,
-  );
-  projectionState.resultSetModifierState.distinct = true;
-  projectionState.resultSetModifierState.limit = TYPEAHEAD_TAKE_LIMIT;
-  return builderState;
-};
-
-const buildColumnTypeaheadQuery = (
-  builderState: QueryBuilderState,
-  columnState:
-    | QueryBuilderProjectionColumnState
-    | QueryBuilderAggregateColumnState,
-  value: ValueSpecification | undefined,
-): RawLambda => {
-  const projectionState = guaranteeType(
-    builderState.fetchStructureState.implementation,
-    QueryBuilderProjectionState,
-  );
-  let projectionColumnState;
-  if (columnState instanceof QueryBuilderProjectionColumnState) {
-    projectionColumnState = columnState;
-  } else {
-    projectionColumnState = columnState.projectionColumnState;
-    const aggregationState = projectionState.aggregationState;
-    aggregationState.columns = [columnState];
-  }
-  projectionState.columns = [projectionColumnState];
-  const postConditionState = new PostFilterConditionState(
-    projectionState.postFilterState,
-    columnState,
-    value,
-    new QueryBuilderPostFilterOperator_StartWith(),
-  );
-  const postFilterNode = new QueryBuilderPostFilterTreeConditionNodeData(
-    undefined,
-    postConditionState,
-  );
-  projectionState.postFilterState.addNodeFromNode(postFilterNode, undefined);
-  return builderState.resultState.buildExecutionRawLambda();
-};
-
-export const buildPropertyTypeaheadQuery = (
-  queryBuilderState: QueryBuilderState,
-  propertyExpression: AbstractPropertyExpression,
-  value: ValueSpecification | undefined,
-): RawLambda => {
-  const builderState = initializeQueryBuilderState(queryBuilderState);
-  const projectionState = guaranteeType(
-    builderState.fetchStructureState.implementation,
-    QueryBuilderProjectionState,
-  );
-  const columnState = new QueryBuilderSimpleProjectionColumnState(
-    projectionState,
-    propertyExpression,
-    false,
-  );
-  return buildColumnTypeaheadQuery(builderState, columnState, value);
-};
-
-export const buildProjectionColumnTypeaheadQuery = (
-  queryBuilderState: QueryBuilderState,
-  columnState:
-    | QueryBuilderProjectionColumnState
-    | QueryBuilderAggregateColumnState,
-  value: ValueSpecification | undefined,
-): RawLambda => {
-  const builderState = initializeQueryBuilderState(queryBuilderState);
-  return buildColumnTypeaheadQuery(builderState, columnState, value);
-};
-
-export const buildTypeaheadOptions = (result: ExecutionResult): string[] => {
-  const tdsResult = guaranteeType(
-    result,
-    TdsExecutionResult,
-    'Typeahead search is only supported for TDS result sets',
-  );
-  const options: string[] = [];
-  tdsResult.result.rows
-    .map((r) => r.values[0])
-    .filter(isNonNullable)
-    .forEach((r) => {
-      if (isString(r)) {
-        options.push(r);
-      }
-    });
-  return options;
-};
-
-export const performTypeahead = (
-  val: ValueSpecification | undefined,
-): boolean => {
-  if (val instanceof PrimitiveInstanceValue) {
-    const _type = val.genericType.value.rawType;
-    switch (_type.path) {
-      case PRIMITIVE_TYPE.STRING: {
-        const value = val.values[0] as string;
-        return value.length >= START_LENGTH;
-      }
-      default:
-        return false;
-    }
-  }
-  return false;
-};

package/src/stores/query-builder/QueryBuilderUnsupportedQueryState.ts

@@ -1,44 +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 { makeObservable, action, observable } from 'mobx';
-import type { QueryBuilderState } from './QueryBuilderState.js';
-import type { RawLambda } from '@finos/legend-graph';
-
-export class QueryBuilderUnsupportedQueryState {
-  queryBuilderState: QueryBuilderState;
-  rawLambda?: RawLambda | undefined;
-  lambdaError?: Error | undefined;
-
-  constructor(queryBuilderState: QueryBuilderState) {
-    makeObservable(this, {
-      rawLambda: observable,
-      lambdaError: observable,
-      setRawLambda: action,
-      setLambdaError: action,
-    });
-
-    this.queryBuilderState = queryBuilderState;
-  }
-
-  setRawLambda(val: RawLambda | undefined): void {
-    this.rawLambda = val;
-  }
-
-  setLambdaError(val: Error | undefined): void {
-    this.lambdaError = val;
-  }
-}

package/src/stores/query-builder/QueryBuilderValueSpecificationBuilder.ts

@@ -1,179 +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 { guaranteeNonNullable } from '@finos/legend-shared';
-import {
-  type Class,
-  type Multiplicity,
-  getMilestoneTemporalStereotype,
-  extractElementNameFromPath,
-  InstanceValue,
-  PackageableElementExplicitReference,
-  CORE_PURE_PATH,
-  FunctionType,
-  GenericType,
-  GenericTypeExplicitReference,
-  LambdaFunction,
-  SimpleFunctionExpression,
-  TYPICAL_MULTIPLICITY_TYPE,
-  MILESTONING_STEREOTYPE,
-} from '@finos/legend-graph';
-import type { QueryBuilderState } from './QueryBuilderState.js';
-import { buildParametersLetLambdaFunc } from '@finos/legend-application';
-import { buildFilterExpression } from './filter/QueryBuilderFilterValueSpecificationBuilder.js';
-import type { LambdaFunctionBuilderOption } from './QueryBuilderValueSpecificationBuilderHelper.js';
-import type { QueryBuilderFetchStructureState } from './fetch-structure/QueryBuilderFetchStructureState.js';
-import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../graphManager/QueryBuilderSupportedFunctions.js';
-
-const buildGetAllFunction = (
-  _class: Class,
-  multiplicity: Multiplicity,
-): SimpleFunctionExpression => {
-  const _func = new SimpleFunctionExpression(
-    extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.GET_ALL),
-    multiplicity,
-  );
-  const classInstance = new InstanceValue(
-    multiplicity,
-    GenericTypeExplicitReference.create(new GenericType(_class)),
-  );
-  classInstance.values[0] = PackageableElementExplicitReference.create(_class);
-  _func.parametersValues.push(classInstance);
-  return _func;
-};
-
-const buildFetchStructure = (
-  fetchStructureState: QueryBuilderFetchStructureState,
-  lambdaFunction: LambdaFunction,
-  options?: LambdaFunctionBuilderOption,
-): void => {
-  fetchStructureState.implementation.appendFetchStructure(
-    lambdaFunction,
-    options,
-  );
-};
-
-export const buildLambdaFunction = (
-  queryBuilderState: QueryBuilderState,
-  options?: LambdaFunctionBuilderOption,
-): LambdaFunction => {
-  const _class = guaranteeNonNullable(
-    queryBuilderState.class,
-    'Class is required to build query',
-  );
-  const multiplicityOne =
-    queryBuilderState.graphManagerState.graph.getTypicalMultiplicity(
-      TYPICAL_MULTIPLICITY_TYPE.ONE,
-    );
-  const typeAny = queryBuilderState.graphManagerState.graph.getType(
-    CORE_PURE_PATH.ANY,
-  );
-  const lambdaFunction = new LambdaFunction(
-    new FunctionType(typeAny, multiplicityOne),
-  );
-
-  // build getAll()
-  const getAllFunction = buildGetAllFunction(_class, multiplicityOne);
-
-  // build milestoning parameter(s) for getAll()
-  const milestoningStereotype = getMilestoneTemporalStereotype(
-    _class,
-    queryBuilderState.graphManagerState.graph,
-  );
-  if (milestoningStereotype) {
-    switch (milestoningStereotype) {
-      case MILESTONING_STEREOTYPE.BUSINESS_TEMPORAL: {
-        getAllFunction.parametersValues.push(
-          guaranteeNonNullable(
-            queryBuilderState.milestoningState.businessDate,
-            `Milestoning class should have a parameter of type 'Date'`,
-          ),
-        );
-        break;
-      }
-      case MILESTONING_STEREOTYPE.PROCESSING_TEMPORAL: {
-        getAllFunction.parametersValues.push(
-          guaranteeNonNullable(
-            queryBuilderState.milestoningState.processingDate,
-            `Milestoning class should have a parameter of type 'Date'`,
-          ),
-        );
-        break;
-      }
-      case MILESTONING_STEREOTYPE.BITEMPORAL: {
-        getAllFunction.parametersValues.push(
-          guaranteeNonNullable(
-            queryBuilderState.milestoningState.processingDate,
-            `Milestoning class should have a parameter of type 'Date'`,
-          ),
-        );
-        getAllFunction.parametersValues.push(
-          guaranteeNonNullable(
-            queryBuilderState.milestoningState.businessDate,
-            `Milestoning class should have a parameter of type 'Date'`,
-          ),
-        );
-        break;
-      }
-      default:
-    }
-  }
-  lambdaFunction.expressionSequence[0] = getAllFunction;
-
-  // build filter
-  const filterFunction = buildFilterExpression(
-    queryBuilderState.filterState,
-    getAllFunction,
-  );
-  if (filterFunction) {
-    lambdaFunction.expressionSequence[0] = filterFunction;
-  }
-
-  // build fetch-structure
-  buildFetchStructure(
-    queryBuilderState.fetchStructureState,
-    lambdaFunction,
-    options,
-  );
-
-  // build parameters
-  if (
-    !queryBuilderState.isParameterSupportDisabled &&
-    queryBuilderState.parametersState.parameterStates.length
-  ) {
-    // NOTE: if we are executing:
-    // 1. set the parameters to empty
-    // 2. add let statements for each parameter
-    if (options?.isBuildingExecutionQuery) {
-      lambdaFunction.functionType.parameters = [];
-      const letsFuncs = buildParametersLetLambdaFunc(
-        queryBuilderState.graphManagerState.graph,
-        queryBuilderState.parametersState.parameterStates,
-      );
-      lambdaFunction.expressionSequence = [
-        ...letsFuncs.expressionSequence,
-        ...lambdaFunction.expressionSequence,
-      ];
-    } else {
-      lambdaFunction.functionType.parameters =
-        queryBuilderState.parametersState.parameterStates.map(
-          (e) => e.parameter,
-        );
-    }
-  }
-
-  return lambdaFunction;
-};