@finos/legend-application-query 6.0.0 → 7.0.1

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/query-builder/QueryBuilderChangeDetectionState.ts

@@ -1,37 +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 { RawLambda } from '@finos/legend-graph';
-import { hashObject } from '@finos/legend-shared';
-import type { QueryBuilderState } from './QueryBuilderState.js';
-
-export class QueryBuilderChangeDetectionState {
-  querybuildState: QueryBuilderState;
-  queryHashCode = hashObject(new RawLambda(undefined, undefined));
-  isEnabled = false;
-
-  constructor(queryBuilderState: QueryBuilderState) {
-    this.querybuildState = queryBuilderState;
-  }
-
-  setQueryHashCode(val: string): void {
-    this.queryHashCode = val;
-  }
-
-  setIsEnabled(val: boolean): void {
-    this.isEnabled = val;
-  }
-}

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

@@ -1,34 +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.
- */
-
-export enum QUERY_BUILDER_SOURCE_ID_LABEL {
-  QUERY_BUILDER = 'query-builder',
-  PROJECTION = 'projection',
-}
-
-export const DEFAULT_LAMBDA_VARIABLE_NAME = 'x';
-export const DEFAULT_VARIABLE_NAME = 'var';
-export const DEFAULT_POST_FILTER_LAMBDA_VARIABLE_NAME = 'row';
-
-export const QUERY_BUILDER_PROPERTY_SEARCH_MAX_DEPTH = 5;
-export const QUERY_BUILDER_PROPERTY_SEARCH_RESULTS_LIMIT = 100;
-export enum QUERY_BUILDER_PROPERTY_SEARCH_TYPE {
-  CLASS = 'CLASS',
-  STRING = 'STRING',
-  BOOLEAN = 'BOOLEAN',
-  NUMBER = 'NUMBER',
-  DATE = 'DATE',
-}

package/src/stores/query-builder/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 '../../graphManager/QueryBuilderSupportedFunctions.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/query-builder/QueryBuilderMilestoningState.ts

@@ -1,164 +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 { LambdaParameterState } from '@finos/legend-application';
-import {
-  DEFAULT_BUSINESS_DATE_MILESTONING_PARAMETER_NAME,
-  DEFAULT_PROCESSING_DATE_MILESTONING_PARAMETER_NAME,
-  GenericType,
-  GenericTypeExplicitReference,
-  getMilestoneTemporalStereotype,
-  MILESTONING_STEREOTYPE,
-  observe_ValueSpecification,
-  PRIMITIVE_TYPE,
-  TYPICAL_MULTIPLICITY_TYPE,
-  VariableExpression,
-  type ValueSpecification,
-} from '@finos/legend-graph';
-import { action, computed, makeObservable, observable } from 'mobx';
-import type { QueryBuilderState } from './QueryBuilderState.js';
-
-export class QueryBuilderMilestoningState {
-  queryBuilderState: QueryBuilderState;
-
-  showMilestoningEditor = false;
-  // TODO: Change this when we modify how we deal with milestoning.
-  // See https://github.com/finos/legend-studio/issues/1149
-  businessDate?: ValueSpecification | undefined;
-  processingDate?: ValueSpecification | undefined;
-
-  constructor(queryBuilderState: QueryBuilderState) {
-    makeObservable(this, {
-      processingDate: observable,
-      businessDate: observable,
-      showMilestoningEditor: observable,
-      isMilestonedQuery: computed,
-      setProcessingDate: action,
-      setBusinessDate: action,
-      setShowMilestoningEditor: action,
-    });
-
-    this.queryBuilderState = queryBuilderState;
-  }
-
-  get isMilestonedQuery(): boolean {
-    return Boolean(this.businessDate ?? this.processingDate);
-  }
-
-  setShowMilestoningEditor(val: boolean): void {
-    this.showMilestoningEditor = val;
-  }
-
-  private initializeQueryMilestoningParameters(stereotype: string): void {
-    switch (stereotype) {
-      case MILESTONING_STEREOTYPE.BUSINESS_TEMPORAL: {
-        this.setBusinessDate(
-          this.buildMilestoningParameter(
-            DEFAULT_BUSINESS_DATE_MILESTONING_PARAMETER_NAME,
-          ),
-        );
-        break;
-      }
-      case MILESTONING_STEREOTYPE.PROCESSING_TEMPORAL: {
-        this.setProcessingDate(
-          this.buildMilestoningParameter(
-            DEFAULT_PROCESSING_DATE_MILESTONING_PARAMETER_NAME,
-          ),
-        );
-        break;
-      }
-      case MILESTONING_STEREOTYPE.BITEMPORAL: {
-        this.setProcessingDate(
-          this.buildMilestoningParameter(
-            DEFAULT_PROCESSING_DATE_MILESTONING_PARAMETER_NAME,
-          ),
-        );
-        this.setBusinessDate(
-          this.buildMilestoningParameter(
-            DEFAULT_BUSINESS_DATE_MILESTONING_PARAMETER_NAME,
-          ),
-        );
-        break;
-      }
-      default:
-    }
-  }
-
-  setProcessingDate(val: ValueSpecification | undefined): void {
-    this.processingDate = val
-      ? observe_ValueSpecification(
-          val,
-          this.queryBuilderState.observableContext,
-        )
-      : val;
-  }
-
-  setBusinessDate(val: ValueSpecification | undefined): void {
-    this.businessDate = val
-      ? observe_ValueSpecification(
-          val,
-          this.queryBuilderState.observableContext,
-        )
-      : val;
-  }
-
-  updateMilestoningConfiguration(): void {
-    const currentclass = this.queryBuilderState.class;
-    if (currentclass !== undefined) {
-      const stereotype = getMilestoneTemporalStereotype(
-        currentclass,
-        this.queryBuilderState.graphManagerState.graph,
-      );
-      this.setBusinessDate(undefined);
-      this.setProcessingDate(undefined);
-      if (stereotype) {
-        this.initializeQueryMilestoningParameters(stereotype);
-        // Show the parameter panel because we populate paramaters state with milestoning parameters
-        this.queryBuilderState.setShowParametersPanel(true);
-      }
-    }
-  }
-
-  buildMilestoningParameter(parameterName: string): ValueSpecification {
-    const milestoningParameter = new VariableExpression(
-      parameterName,
-      this.queryBuilderState.graphManagerState.graph.getTypicalMultiplicity(
-        TYPICAL_MULTIPLICITY_TYPE.ONE,
-      ),
-      GenericTypeExplicitReference.create(
-        new GenericType(
-          this.queryBuilderState.parametersState.queryBuilderState.graphManagerState.graph.getPrimitiveType(
-            PRIMITIVE_TYPE.DATE,
-          ),
-        ),
-      ),
-    );
-    if (
-      !this.queryBuilderState.parametersState.parameterStates.find(
-        (p) => p.variableName === parameterName,
-      )
-    ) {
-      const variableState = new LambdaParameterState(
-        milestoningParameter,
-        this.queryBuilderState.observableContext,
-        this.queryBuilderState.graphManagerState.graph,
-      );
-      variableState.mockParameterValue();
-      this.queryBuilderState.parametersState.addParameter(variableState);
-    }
-    return milestoningParameter;
-  }
-}

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

@@ -1,52 +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 {
-  LambdaParametersState,
-  type LambdaParameterState,
-} from '@finos/legend-application';
-import { observable, makeObservable, action } from 'mobx';
-import type { QueryBuilderState } from './QueryBuilderState.js';
-
-export const QUERY_BUILDER_PARAMETER_DND_TYPE = 'PARAMETER';
-
-export interface QueryBuilderParameterDragSource {
-  variable: LambdaParameterState;
-}
-
-export class QueryBuilderParametersState extends LambdaParametersState {
-  selectedParameter: LambdaParameterState | undefined;
-  queryBuilderState: QueryBuilderState;
-
-  constructor(queryBuilderState: QueryBuilderState) {
-    super();
-    makeObservable(this, {
-      parameterValuesEditorState: observable,
-      parameterStates: observable,
-      addParameter: action,
-      removeParameter: action,
-      setParameters: action,
-      selectedParameter: observable,
-      setSelectedParameter: action,
-    });
-
-    this.queryBuilderState = queryBuilderState;
-  }
-
-  setSelectedParameter(val: LambdaParameterState | undefined): void {
-    this.selectedParameter = val;
-  }
-}