@finos/legend-query-builder 0.0.1

package/src/stores/QueryBuilderTextEditorState.ts

@@ -0,0 +1,203 @@
+/**
+ * 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.initializeWithQuery(this.rawLambdaState.lambda);
+        this.setMode(undefined);
+      }
+      return;
+    }
+    this.setMode(undefined);
+  }
+}

package/src/stores/QueryBuilderTypeaheadHelper.ts

@@ -0,0 +1,152 @@
+/**
+ * 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/QueryBuilderUnsupportedQueryState.ts

@@ -0,0 +1,44 @@
+/**
+ * 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/QueryBuilderValueSpecificationBuilder.ts

@@ -0,0 +1,179 @@
+/**
+ * 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;
+};