@finos/legend-application-query 5.2.8 → 7.0.0

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

@@ -1,296 +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 {
-  EngineRuntime,
-  GraphBuilderError,
-  MappingInclude,
-  V1_getIncludedMappingPath,
-  V1_GraphBuilderContextBuilder,
-  V1_Mapping,
-  V1_MAPPING_ELEMENT_PROTOCOL_TYPE,
-  V1_PACKAGEABLE_RUNTIME_ELEMENT_PROTOCOL_TYPE,
-  V1_PureMultiExecution,
-  V1_Service,
-  V1_PackageableRuntime,
-  type V1_PackageableElement,
-  type PureModel,
-  V1_PureGraphManager,
-  PureClientVersion,
-  type AbstractPureGraphManager,
-  type V1_EngineRuntime,
-  CORE_PURE_PATH,
-  getAllIncludedMappings,
-} from '@finos/legend-graph';
-import type { Entity } from '@finos/legend-storage';
-import {
-  assertErrorThrown,
-  filterByType,
-  guaranteeNonEmptyString,
-  guaranteeType,
-  type PlainObject,
-} from '@finos/legend-shared';
-import { MappingRuntimeCompatibilityAnalysisResult } from '../../../action/analytics/MappingRuntimeCompatibilityAnalysis.js';
-import { ServiceExecutionAnalysisResult } from '../../../action/analytics/ServiceExecutionAnalysis.js';
-import { QueryBuilder_PureGraphManagerExtension } from '../QueryBuilder_PureGraphManagerExtension.js';
-
-export class V1_QueryBuilder_PureGraphManagerExtension extends QueryBuilder_PureGraphManagerExtension {
-  declare graphManager: V1_PureGraphManager;
-
-  constructor(graphManager: AbstractPureGraphManager) {
-    super(graphManager);
-    this.graphManager = guaranteeType(graphManager, V1_PureGraphManager);
-  }
-
-  getSupportedProtocolVersion(): string {
-    return PureClientVersion.V1_0_0;
-  }
-
-  // We could optimize this further by omitting parts of the entities we don't need
-  async buildGraphForCreateQuerySetup(
-    graph: PureModel,
-    entities: Entity[],
-    dependencyEntities: Map<string, Entity[]>,
-  ): Promise<void> {
-    try {
-      const graphBuilderInput = await this.graphManager.indexLightGraph(
-        graph,
-        entities,
-        dependencyEntities,
-        (entity: Entity): boolean =>
-          ((entity.content as PlainObject<V1_PackageableElement>)
-            ._type as string) === V1_MAPPING_ELEMENT_PROTOCOL_TYPE ||
-          ((entity.content as PlainObject<V1_PackageableElement>)
-            ._type as string) === V1_PACKAGEABLE_RUNTIME_ELEMENT_PROTOCOL_TYPE,
-      );
-      // handle mapping includes
-      const mappings = [
-        ...graph.ownMappings,
-        ...graph.dependencyManager.mappings,
-      ];
-      const v1Mappings = graphBuilderInput
-        .map((e) => e.data.elements.filter(filterByType(V1_Mapping)))
-        .flat();
-      const context = new V1_GraphBuilderContextBuilder(
-        graph,
-        graph,
-        this.graphManager.graphBuilderExtensions,
-        this.graphManager.log,
-      ).build();
-      // build include index for compatible runtime analysis
-      v1Mappings.forEach((element) => {
-        const mapping = mappings.find((e) => e.path === element.path);
-        if (mapping) {
-          mapping.includes = element.includedMappings.map(
-            (i) =>
-              new MappingInclude(
-                mapping,
-                context.resolveMapping(
-                  guaranteeNonEmptyString(
-                    V1_getIncludedMappingPath(i),
-                    `Mapping include path is missing or empty`,
-                  ),
-                ),
-              ),
-          );
-        }
-      });
-      // handle runtimes
-      const runtimes = [
-        ...graph.ownRuntimes,
-        ...graph.dependencyManager.runtimes,
-      ];
-      const v1Runtimes = graphBuilderInput
-        .map((e) => e.data.elements.filter(filterByType(V1_PackageableRuntime)))
-        .flat();
-      v1Runtimes.forEach((element) => {
-        const runtime = runtimes.find((e) => e.path === element.path);
-        if (runtime) {
-          const runtimeValue = new EngineRuntime();
-          runtime.runtimeValue = runtimeValue;
-          runtimeValue.mappings = element.runtimeValue.mappings.map((mapping) =>
-            context.resolveMapping(mapping.path),
-          );
-        }
-      });
-    } catch (error) {
-      assertErrorThrown(error);
-      /**
-       * Wrap all error with `GraphBuilderError`, as we throw a lot of assertion error in the graph builder
-       * But we might want to rethink this decision in the future and throw appropriate type of error
-       */
-      throw error instanceof GraphBuilderError
-        ? error
-        : new GraphBuilderError(error);
-    }
-  }
-
-  async surveyMappingRuntimeCompatibility(
-    entities: Entity[],
-    dependencyEntities: Map<string, Entity[]>,
-  ): Promise<MappingRuntimeCompatibilityAnalysisResult[]> {
-    const result: MappingRuntimeCompatibilityAnalysisResult[] = [];
-    const graph = await this.graphManager.createEmptyGraph({
-      initializeSystem: false,
-    });
-
-    const graphBuilderInput = await this.graphManager.indexLightGraph(
-      graph,
-      entities,
-      dependencyEntities,
-      (entity: Entity): boolean =>
-        ([CORE_PURE_PATH.MAPPING, CORE_PURE_PATH.RUNTIME] as string[]).includes(
-          entity.classifierPath,
-        ),
-      // NOTE: small optimization since we only need to survey runtimes and mappings
-      (entity: Entity): Entity => {
-        if (entity.classifierPath === CORE_PURE_PATH.MAPPING) {
-          entity.content = {
-            _type: entity.content._type,
-            name: entity.content.name,
-            package: entity.content.package,
-            includes: entity.content.includes,
-          };
-        } else if (entity.classifierPath === CORE_PURE_PATH.RUNTIME) {
-          entity.content = {
-            _type: entity.content._type,
-            name: entity.content.name,
-            package: entity.content.package,
-            runtimeValue: {
-              mappings: (
-                entity.content.runtimeValue as
-                  | PlainObject<V1_EngineRuntime>
-                  | undefined
-              )?.mappings,
-            },
-          };
-        }
-        return entity;
-      },
-    );
-
-    const context = new V1_GraphBuilderContextBuilder(
-      graph,
-      graph,
-      this.graphManager.graphBuilderExtensions,
-      this.graphManager.log,
-    ).build();
-
-    graphBuilderInput
-      .map((element) => element.data.elements.filter(filterByType(V1_Mapping)))
-      .flat()
-      .forEach((element) => {
-        const mapping = graph.getNullableMapping(element.path);
-        if (mapping) {
-          mapping.includes = element.includedMappings.map(
-            (include) =>
-              new MappingInclude(
-                mapping,
-                context.resolveMapping(
-                  guaranteeNonEmptyString(
-                    V1_getIncludedMappingPath(include),
-                    `Mapping include path is missing or empty`,
-                  ),
-                ),
-              ),
-          );
-        }
-      });
-
-    graphBuilderInput
-      .map((element) =>
-        element.data.elements.filter(filterByType(V1_PackageableRuntime)),
-      )
-      .flat()
-      .forEach((element) => {
-        const runtime = graph.getNullableRuntime(element.path);
-        if (runtime) {
-          const runtimeValue = new EngineRuntime();
-          runtime.runtimeValue = runtimeValue;
-          runtimeValue.mappings = element.runtimeValue.mappings.map((mapping) =>
-            context.resolveMapping(mapping.path),
-          );
-        }
-      });
-
-    graph.mappings.forEach((mapping) => {
-      const mappingRuntimeCompatibilityAnalysisResult =
-        new MappingRuntimeCompatibilityAnalysisResult();
-      mappingRuntimeCompatibilityAnalysisResult.mapping = mapping;
-      mappingRuntimeCompatibilityAnalysisResult.runtimes =
-        // If the runtime claims to cover some mappings which include the specified mapping,
-        // then we deem the runtime to be compatible with the such mapping
-        graph.runtimes.filter((runtime) =>
-          runtime.runtimeValue.mappings
-            .map((mappingReference) => [
-              mappingReference.value,
-              ...getAllIncludedMappings(mappingReference.value),
-            ])
-            .flat()
-            .includes(mapping),
-        );
-      result.push(mappingRuntimeCompatibilityAnalysisResult);
-    });
-
-    return result;
-  }
-
-  async surveyServiceExecution(
-    entities: Entity[],
-    dependencyEntities: Map<string, Entity[]>,
-  ): Promise<ServiceExecutionAnalysisResult[]> {
-    const result: ServiceExecutionAnalysisResult[] = [];
-    const graph = await this.graphManager.createEmptyGraph({
-      initializeSystem: false,
-    });
-
-    const graphBuilderInput = await this.graphManager.indexLightGraph(
-      graph,
-      entities,
-      dependencyEntities,
-      (entity: Entity): boolean =>
-        entity.classifierPath === CORE_PURE_PATH.SERVICE,
-      // NOTE: small optimization since we only need to inspect services' execution context
-      (entity: Entity): Entity => {
-        if (entity.classifierPath === CORE_PURE_PATH.SERVICE) {
-          entity.content = {
-            _type: entity.content._type,
-            name: entity.content.name,
-            package: entity.content.package,
-            execution: entity.content.execution,
-          };
-        }
-        return entity;
-      },
-    );
-    graphBuilderInput
-      .map((element) => element.data.elements.filter(filterByType(V1_Service)))
-      .flat()
-      .forEach((protocol) => {
-        const service = graph.getNullableService(protocol.path);
-        if (service) {
-          const serviceAnalysisResult = new ServiceExecutionAnalysisResult();
-          serviceAnalysisResult.service = service;
-          if (protocol.execution instanceof V1_PureMultiExecution) {
-            serviceAnalysisResult.executionKeys =
-              protocol.execution.executionParameters.map((param) => param.key);
-          }
-          result.push(serviceAnalysisResult);
-        }
-      });
-    return result;
-  }
-}

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();
-};