@finos/legend-application-query 5.2.8 → 6.0.0

package/src/components/shared/QueryBuilderLambdaEditor.tsx

@@ -1,120 +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 { flowResult } from 'mobx';
-import { observer } from 'mobx-react-lite';
-import { type IKeyboardEvent, KeyCode } from 'monaco-editor';
-import { useCallback, useMemo } from 'react';
-import type { QueryBuilderState } from '../../stores/QueryBuilderState.js';
-import type { Type } from '@finos/legend-graph';
-import {
-  useApplicationStore,
-  LambdaEditor,
-  type LambdaEditorState,
-  type LambdaEditorOnKeyDownEventHandler,
-} from '@finos/legend-application';
-
-export const QueryBuilderLambdaEditor = observer(
-  (props: {
-    queryBuilderState: QueryBuilderState;
-    className?: string;
-    disabled: boolean;
-    lambdaEditorState: LambdaEditorState;
-    /**
-     * TODO: when we pass in these expected type we should match a type as expected type if it's covariance, i.e. it is a subtype of
-     * the expected type. Note that we also have to handle that relationship for Primitive type
-     * See https://dzone.com/articles/covariance-and-contravariance
-     */
-    expectedType?: Type;
-    matchedExpectedType?: () => boolean;
-    onExpectedTypeLabelSelect?: () => void;
-    forceBackdrop: boolean;
-    disableExpansion?: boolean | undefined;
-    forceExpansion?: boolean | undefined;
-    disablePopUp?: boolean | undefined;
-    useBaseTextEditorSettings?: boolean | undefined;
-    hideErrorBar?: boolean | undefined;
-    onEditorFocusEventHandler?: (() => void) | undefined;
-  }) => {
-    const {
-      queryBuilderState,
-      className,
-      lambdaEditorState,
-      disabled,
-      forceBackdrop,
-      expectedType,
-      onExpectedTypeLabelSelect,
-      matchedExpectedType,
-      disableExpansion,
-      forceExpansion,
-      disablePopUp,
-      useBaseTextEditorSettings,
-      hideErrorBar,
-      onEditorFocusEventHandler,
-    } = props;
-    const applicationStore = useApplicationStore();
-    const backdropSetter = useCallback(
-      (val: boolean) => queryBuilderState.setBackdrop(val),
-      [queryBuilderState],
-    );
-    const onKeyDownEventHandlers: LambdaEditorOnKeyDownEventHandler[] = useMemo(
-      () => [
-        {
-          matcher: (event: IKeyboardEvent): boolean =>
-            event.keyCode === KeyCode.F9,
-          action: (event: IKeyboardEvent): void => {
-            const handler = async (): Promise<void> => {
-              lambdaEditorState.clearErrors();
-              if (!disabled) {
-                await flowResult(
-                  lambdaEditorState.convertLambdaGrammarStringToObject(),
-                );
-                // abort action if parser error occurred
-                if (lambdaEditorState.parserError) {
-                  return;
-                }
-              }
-              await flowResult(queryBuilderState.compileQuery());
-            };
-            handler().catch(applicationStore.alertUnhandledError);
-          },
-        },
-      ],
-      [disabled, lambdaEditorState, applicationStore, queryBuilderState],
-    );
-
-    return (
-      <LambdaEditor
-        key={lambdaEditorState.uuid}
-        className={className}
-        disabled={disabled}
-        lambdaEditorState={lambdaEditorState}
-        expectedType={expectedType}
-        matchedExpectedType={matchedExpectedType}
-        onExpectedTypeLabelSelect={onExpectedTypeLabelSelect}
-        forceBackdrop={forceBackdrop}
-        backdropSetter={backdropSetter}
-        disableExpansion={disableExpansion}
-        forceExpansion={forceExpansion}
-        disablePopUp={disablePopUp}
-        useBaseTextEditorSettings={useBaseTextEditorSettings}
-        hideErrorBar={hideErrorBar}
-        onKeyDownEventHandlers={onKeyDownEventHandlers}
-        onEditorFocusEventHandler={onEditorFocusEventHandler}
-      />
-    );
-  },
-);

package/src/stores/QueryBuilderGroupOperationHelper.ts

@@ -1,54 +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 { matchFunctionName } from '@finos/legend-graph';
-import { UnsupportedOperationError } from '@finos/legend-shared';
-import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../QueryBuilder_Const.js';
-
-export enum QUERY_BUILDER_GROUP_OPERATION {
-  AND = 'and',
-  OR = 'or',
-}
-
-export const fromGroupOperation = (
-  operation: QUERY_BUILDER_GROUP_OPERATION,
-): string => {
-  switch (operation) {
-    case QUERY_BUILDER_GROUP_OPERATION.AND:
-      return QUERY_BUILDER_SUPPORTED_FUNCTIONS.AND;
-    case QUERY_BUILDER_GROUP_OPERATION.OR:
-      return QUERY_BUILDER_SUPPORTED_FUNCTIONS.OR;
-    default:
-      throw new UnsupportedOperationError(
-        `Can't derive function name from group operation '${operation}'`,
-      );
-  }
-};
-
-export const toGroupOperation = (
-  functionName: string,
-): QUERY_BUILDER_GROUP_OPERATION => {
-  if (matchFunctionName(functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.AND)) {
-    return QUERY_BUILDER_GROUP_OPERATION.AND;
-  } else if (
-    matchFunctionName(functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.OR)
-  ) {
-    return QUERY_BUILDER_GROUP_OPERATION.OR;
-  }
-  throw new UnsupportedOperationError(
-    `Can't derive group operation from function name '${functionName}'`,
-  );
-};

package/src/stores/QueryBuilderPreviewDataHelper.ts

@@ -1,210 +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 {
-  RawLambda,
-  AbstractPropertyExpression,
-} from '@finos/legend-graph';
-import { guaranteeNonNullable, guaranteeType } from '@finos/legend-shared';
-import { QueryBuilderAggregateOperator_Average } from './fetch-structure/projection/aggregation/operators/QueryBuilderAggregateOperator_Average.js';
-import { QueryBuilderAggregateOperator_Count } from './fetch-structure/projection/aggregation/operators/QueryBuilderAggregateOperator_Count.js';
-import { QueryBuilderAggregateOperator_DistinctCount } from './fetch-structure/projection/aggregation/operators/QueryBuilderAggregateOperator_DistinctCount.js';
-import { QueryBuilderAggregateOperator_Max } from './fetch-structure/projection/aggregation/operators/QueryBuilderAggregateOperator_Max.js';
-import { QueryBuilderAggregateOperator_Min } from './fetch-structure/projection/aggregation/operators/QueryBuilderAggregateOperator_Min.js';
-import { QueryBuilderAggregateOperator_StdDev_Population } from './fetch-structure/projection/aggregation/operators/QueryBuilderAggregateOperator_StdDev_Population.js';
-import { QueryBuilderAggregateOperator_StdDev_Sample } from './fetch-structure/projection/aggregation/operators/QueryBuilderAggregateOperator_StdDev_Sample.js';
-import { QueryBuilderAggregateOperator_Sum } from './fetch-structure/projection/aggregation/operators/QueryBuilderAggregateOperator_Sum.js';
-import { QueryBuilderSimpleProjectionColumnState } from './fetch-structure/projection/QueryBuilderProjectionColumnState.js';
-import type { QueryBuilderState } from './QueryBuilderState.js';
-import {
-  COLUMN_SORT_TYPE,
-  SortColumnState,
-} from './fetch-structure/projection/QueryResultSetModifierState.js';
-import type { QueryBuilderAggregateOperator } from './fetch-structure/projection/aggregation/QueryBuilderAggregateOperator.js';
-import { QueryBuilderProjectionState } from './fetch-structure/projection/QueryBuilderProjectionState.js';
-
-const PREVIEW_DATA_TAKE_LIMIT = 10;
-const PREVIEW_DATA_NON_NUMERIC_VALUE_COLUMN_NAME = 'Value';
-const PREVIEW_DATA_NON_NUMERIC_COUNT_COLUMN_NAME = 'Count';
-
-enum NUMERIC_AGG_FUNC {
-  COUNT = 'Count',
-  DISTINCT_COUNT = 'Distinct Count',
-  SUM = 'Sum',
-  MIN = 'Min',
-  MAX = 'Max',
-  AVERAGE = 'Average',
-  STD_DEV_POPULATION = 'Std Dev (Population)',
-  STD_DEV_SAMPLE = 'Std Dev (Sample)',
-}
-
-const NUMERIC_AGG_FUNC_TO_AGG_OP: [
-  NUMERIC_AGG_FUNC,
-  typeof QueryBuilderAggregateOperator,
-][] = [
-  [NUMERIC_AGG_FUNC.COUNT, QueryBuilderAggregateOperator_Count],
-  [
-    NUMERIC_AGG_FUNC.DISTINCT_COUNT,
-    QueryBuilderAggregateOperator_DistinctCount,
-  ],
-  [NUMERIC_AGG_FUNC.SUM, QueryBuilderAggregateOperator_Sum],
-  [NUMERIC_AGG_FUNC.MIN, QueryBuilderAggregateOperator_Min],
-  [NUMERIC_AGG_FUNC.MAX, QueryBuilderAggregateOperator_Max],
-  [NUMERIC_AGG_FUNC.AVERAGE, QueryBuilderAggregateOperator_Average],
-  [
-    NUMERIC_AGG_FUNC.STD_DEV_POPULATION,
-    QueryBuilderAggregateOperator_StdDev_Population,
-  ],
-  [
-    NUMERIC_AGG_FUNC.STD_DEV_SAMPLE,
-    QueryBuilderAggregateOperator_StdDev_Sample,
-  ],
-];
-
-const createSimpleProjectionColumn = (
-  projectionState: QueryBuilderProjectionState,
-  propertyExpression: AbstractPropertyExpression,
-  columnName: string,
-): QueryBuilderSimpleProjectionColumnState => {
-  const col = new QueryBuilderSimpleProjectionColumnState(
-    projectionState,
-    propertyExpression,
-    false,
-  );
-  col.setColumnName(columnName);
-  return col;
-};
-
-const createQueryBuilderState = (
-  queryBuilderState: QueryBuilderState,
-): QueryBuilderState => {
-  const builderState = queryBuilderState.cloneQueryBuilderState();
-  builderState.querySetupState = queryBuilderState.querySetupState;
-  return builderState;
-};
-
-export type QueryBuilderPreviewData = {
-  columns: string[];
-  rows: { values: (string | number)[] }[];
-};
-
-export const buildNumericPreviewDataQuery = (
-  queryBuilderState: QueryBuilderState,
-  propertyExpression: AbstractPropertyExpression,
-): RawLambda => {
-  // Build the following query
-  //
-  // ClassX.all()->groupBy(
-  //   [],
-  //   [
-  //     agg(x|$x.prop, x|$x->count()),
-  //     agg(x|$x.prop, x|$x->distinct()->count()),
-  //     agg(x|$x.prop, x|$x->sum()),
-  //     agg(x|$x.prop, x|$x->min()),
-  //     agg(x|$x.prop, x|$x->max()),
-  //     agg(x|$x.prop, x|$x->average()),
-  //     agg(x|$x.prop, x|$x->stdDevPopulation()),
-  //     agg(x|$x.prop, x|$x->stdDevSample())
-  //   ],
-  //   [
-  //     'Count',
-  //     'Distinct Count',
-  //     'Sum',
-  //     'Min',
-  //     'Max',
-  //     'Average',
-  //     'Std Dev (Population)',
-  //     'Std Dev (Sample)'
-  //   ]
-  // )
-  const builderState = createQueryBuilderState(queryBuilderState);
-  const projectionState = guaranteeType(
-    builderState.fetchStructureState.implementation,
-    QueryBuilderProjectionState,
-  );
-  const aggregationState = projectionState.aggregationState;
-  NUMERIC_AGG_FUNC_TO_AGG_OP.forEach((val) => {
-    const colState = createSimpleProjectionColumn(
-      projectionState,
-      propertyExpression,
-      val[0],
-    );
-    projectionState.columns.push(colState);
-    const valAggOp = guaranteeNonNullable(
-      aggregationState.operators.find((t) => t instanceof val[1]),
-    );
-    aggregationState.changeColumnAggregateOperator(valAggOp, colState);
-  });
-
-  return builderState.resultState.buildExecutionRawLambda();
-};
-
-export const buildNonNumericPreviewDataQuery = (
-  queryBuilderState: QueryBuilderState,
-  propertyExpression: AbstractPropertyExpression,
-): RawLambda => {
-  // Build the following query
-  //
-  // ClassX.all()->groupBy(
-  //   [
-  //     x|$x.prop
-  //   ],
-  //   [
-  //     agg(x|$x.prop, x|$x->count())
-  //   ],
-  //   [
-  //     'Value',
-  //     'Count'
-  //   ]
-  // )->sort([desc('Count'), asc('Value')])->take(10)
-  const builderState = createQueryBuilderState(queryBuilderState);
-  const projectionState = guaranteeType(
-    builderState.fetchStructureState.implementation,
-    QueryBuilderProjectionState,
-  );
-  const valueProjectionColState = createSimpleProjectionColumn(
-    projectionState,
-    propertyExpression,
-    PREVIEW_DATA_NON_NUMERIC_VALUE_COLUMN_NAME,
-  );
-  const valueCountProjectionState = createSimpleProjectionColumn(
-    projectionState,
-    propertyExpression,
-    PREVIEW_DATA_NON_NUMERIC_COUNT_COLUMN_NAME,
-  );
-  projectionState.columns = [
-    valueProjectionColState,
-    valueCountProjectionState,
-  ];
-  const distinctCountOp = guaranteeNonNullable(
-    projectionState.aggregationState.operators.find(
-      (t) => t instanceof QueryBuilderAggregateOperator_Count,
-    ),
-  );
-  projectionState.aggregationState.changeColumnAggregateOperator(
-    distinctCountOp,
-    valueCountProjectionState,
-  );
-  // result set
-  projectionState.resultSetModifierState.limit = PREVIEW_DATA_TAKE_LIMIT;
-  const sortValueCount = new SortColumnState(valueCountProjectionState);
-  sortValueCount.sortType = COLUMN_SORT_TYPE.DESC;
-  projectionState.resultSetModifierState.sortColumns = [
-    sortValueCount,
-    new SortColumnState(valueProjectionColState),
-  ];
-  return builderState.resultState.buildExecutionRawLambda();
-};