@finos/legend-application-query 5.2.8 → 6.0.0

package/src/stores/QueryBuilderResultState.ts

@@ -1,281 +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 { action, makeAutoObservable } from 'mobx';
-import {
-  type GeneratorFn,
-  assertErrorThrown,
-  LogEvent,
-  guaranteeNonNullable,
-  ContentType,
-  guaranteeType,
-  downloadFileUsingDataURI,
-  UnsupportedOperationError,
-  ActionState,
-} from '@finos/legend-shared';
-import type { QueryBuilderState } from './QueryBuilderState.js';
-import {
-  type RawExecutionPlan,
-  type ExecutionResult,
-  type RawLambda,
-  GRAPH_MANAGER_EVENT,
-  EXECUTION_SERIALIZATION_FORMAT,
-  RawExecutionResult,
-  buildRawLambdaFromLambdaFunction,
-} from '@finos/legend-graph';
-import { buildLambdaFunction } from './QueryBuilderValueSpecificationBuilder.js';
-import {
-  buildParametersLetLambdaFunc,
-  ExecutionPlanState,
-} from '@finos/legend-application';
-
-const DEFAULT_LIMIT = 1000;
-
-export class QueryBuilderResultState {
-  queryBuilderState: QueryBuilderState;
-  exportDataState = ActionState.create();
-  previewLimit = DEFAULT_LIMIT;
-  isRunningQuery = false;
-  isGeneratingPlan = false;
-  executionResult?: ExecutionResult | undefined;
-  executionPlanState: ExecutionPlanState;
-  executionDuration?: number | undefined;
-  queryRunPromise: Promise<ExecutionResult> | undefined = undefined;
-
-  constructor(queryBuilderState: QueryBuilderState) {
-    makeAutoObservable(this, {
-      queryBuilderState: false,
-      executionPlanState: false,
-      setIsRunningQuery: action,
-      setExecutionResult: action,
-    });
-
-    this.queryBuilderState = queryBuilderState;
-    this.executionPlanState = new ExecutionPlanState(
-      this.queryBuilderState.applicationStore,
-      this.queryBuilderState.graphManagerState,
-    );
-  }
-
-  setIsRunningQuery = (val: boolean): void => {
-    this.isRunningQuery = val;
-  };
-
-  setExecutionResult = (val: ExecutionResult | undefined): void => {
-    this.executionResult = val;
-  };
-
-  setExecutionDuration = (val: number | undefined): void => {
-    this.executionDuration = val;
-  };
-
-  setPreviewLimit = (val: number): void => {
-    this.previewLimit = Math.max(1, val);
-  };
-
-  setQueryRunPromise = (
-    promise: Promise<ExecutionResult> | undefined,
-  ): void => {
-    this.queryRunPromise = promise;
-  };
-
-  buildExecutionRawLambda(): RawLambda {
-    let query: RawLambda;
-    if (this.queryBuilderState.isQuerySupported()) {
-      const lambdaFunction = buildLambdaFunction(this.queryBuilderState, {
-        isBuildingExecutionQuery: true,
-      });
-      query = buildRawLambdaFromLambdaFunction(
-        lambdaFunction,
-        this.queryBuilderState.graphManagerState,
-      );
-    } else {
-      query = guaranteeNonNullable(
-        this.queryBuilderState.queryUnsupportedState.rawLambda,
-        'Lambda is required to execute query',
-      );
-      if (
-        !this.queryBuilderState.mode.isParametersDisabled &&
-        this.queryBuilderState.queryParametersState.parameterStates.length
-      ) {
-        const letlambdaFunction = buildParametersLetLambdaFunc(
-          this.queryBuilderState.graphManagerState.graph,
-          this.queryBuilderState.queryParametersState.parameterStates,
-        );
-        const letRawLambda = buildRawLambdaFromLambdaFunction(
-          letlambdaFunction,
-          this.queryBuilderState.graphManagerState,
-        );
-        // reset paramaters
-        if (Array.isArray(query.body) && Array.isArray(letRawLambda.body)) {
-          letRawLambda.body = [
-            ...(letRawLambda.body as object[]),
-            ...(query.body as object[]),
-          ];
-          query = letRawLambda;
-        }
-      }
-    }
-    return query;
-  }
-
-  *exportData(
-    serializationFormat: EXECUTION_SERIALIZATION_FORMAT,
-  ): GeneratorFn<void> {
-    try {
-      this.exportDataState.inProgress();
-      const mapping = guaranteeNonNullable(
-        this.queryBuilderState.querySetupState.mapping,
-        'Mapping is required to execute query',
-      );
-      const runtime = guaranteeNonNullable(
-        this.queryBuilderState.querySetupState.runtimeValue,
-        `Runtime is required to execute query`,
-      );
-      const query = this.buildExecutionRawLambda();
-      const result =
-        (yield this.queryBuilderState.graphManagerState.graphManager.executeMapping(
-          query,
-          mapping,
-          runtime,
-          this.queryBuilderState.graphManagerState.graph,
-          {
-            serializationFormat,
-          },
-        )) as ExecutionResult;
-      let contentType: ContentType;
-      let fileName = 'result';
-      let content: string;
-      switch (serializationFormat) {
-        case EXECUTION_SERIALIZATION_FORMAT.CSV:
-          {
-            const rawResult = guaranteeType(result, RawExecutionResult);
-            contentType = ContentType.TEXT_CSV;
-            fileName = `${fileName}.csv`;
-            content = rawResult.value;
-          }
-          break;
-        default:
-          throw new UnsupportedOperationError(
-            `Can't download file for serialization type: '${serializationFormat}'`,
-          );
-      }
-      downloadFileUsingDataURI(fileName, content, contentType);
-      this.exportDataState.pass();
-    } catch (error) {
-      assertErrorThrown(error);
-      this.queryBuilderState.applicationStore.log.error(
-        LogEvent.create(GRAPH_MANAGER_EVENT.EXECUTION_FAILURE),
-        error,
-      );
-      this.queryBuilderState.applicationStore.notifyError(error);
-      this.exportDataState.fail();
-    }
-  }
-
-  *runQuery(): GeneratorFn<void> {
-    try {
-      this.isRunningQuery = true;
-      const mapping = guaranteeNonNullable(
-        this.queryBuilderState.querySetupState.mapping,
-        'Mapping is required to execute query',
-      );
-      const runtime = guaranteeNonNullable(
-        this.queryBuilderState.querySetupState.runtimeValue,
-        `Runtime is required to execute query`,
-      );
-      const query = this.buildExecutionRawLambda();
-      const startTime = Date.now();
-      const promise =
-        this.queryBuilderState.graphManagerState.graphManager.executeMapping(
-          query,
-          mapping,
-          runtime,
-          this.queryBuilderState.graphManagerState.graph,
-        );
-      this.setQueryRunPromise(promise);
-      const result = (yield promise) as ExecutionResult;
-      if (this.queryRunPromise === promise) {
-        this.setExecutionResult(result);
-        this.setExecutionDuration(Date.now() - startTime);
-      }
-    } catch (error) {
-      assertErrorThrown(error);
-      this.queryBuilderState.applicationStore.log.error(
-        LogEvent.create(GRAPH_MANAGER_EVENT.EXECUTION_FAILURE),
-        error,
-      );
-      this.queryBuilderState.applicationStore.notifyError(error);
-    } finally {
-      this.setIsRunningQuery(false);
-    }
-  }
-
-  *generatePlan(debug: boolean): GeneratorFn<void> {
-    try {
-      this.isGeneratingPlan = true;
-      const mapping = guaranteeNonNullable(
-        this.queryBuilderState.querySetupState.mapping,
-        'Mapping is required to execute query',
-      );
-      const runtime = guaranteeNonNullable(
-        this.queryBuilderState.querySetupState.runtimeValue,
-        `Runtime is required to execute query`,
-      );
-      const query = this.queryBuilderState.getQuery();
-      let rawPlan: RawExecutionPlan;
-      if (debug) {
-        const debugResult =
-          (yield this.queryBuilderState.graphManagerState.graphManager.debugExecutionPlanGeneration(
-            query,
-            mapping,
-            runtime,
-            this.queryBuilderState.graphManagerState.graph,
-          )) as { plan: RawExecutionPlan; debug: string };
-        rawPlan = debugResult.plan;
-        this.executionPlanState.setDebugText(debugResult.debug);
-      } else {
-        rawPlan =
-          (yield this.queryBuilderState.graphManagerState.graphManager.generateExecutionPlan(
-            query,
-            mapping,
-            runtime,
-            this.queryBuilderState.graphManagerState.graph,
-          )) as object;
-      }
-      try {
-        this.executionPlanState.setRawPlan(rawPlan);
-        const plan =
-          this.queryBuilderState.graphManagerState.graphManager.buildExecutionPlan(
-            rawPlan,
-            this.queryBuilderState.graphManagerState.graph,
-          );
-        this.executionPlanState.setPlan(plan);
-      } catch {
-        // do nothing
-      }
-    } catch (error) {
-      assertErrorThrown(error);
-      this.queryBuilderState.applicationStore.log.error(
-        LogEvent.create(GRAPH_MANAGER_EVENT.EXECUTION_FAILURE),
-        error,
-      );
-      this.queryBuilderState.applicationStore.notifyError(error);
-    } finally {
-      this.isGeneratingPlan = false;
-    }
-  }
-}

package/src/stores/QueryBuilderSetupState.ts

@@ -1,236 +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 { action, makeAutoObservable, observable } from 'mobx';
-import { getNullableFirstElement, uniq } from '@finos/legend-shared';
-import type { QueryBuilderState } from './QueryBuilderState.js';
-import {
-  type Class,
-  type Mapping,
-  type PackageableRuntime,
-  type Runtime,
-  type ValueSpecification,
-  getMilestoneTemporalStereotype,
-  PackageableElementExplicitReference,
-  RuntimePointer,
-  DEFAULT_BUSINESS_DATE_MILESTONING_PARAMETER_NAME,
-  DEFAULT_PROCESSING_DATE_MILESTONING_PARAMETER_NAME,
-  MILESTONING_STEREOTYPE,
-  observe_ValueSpecification,
-  getAllIncludedMappings,
-} from '@finos/legend-graph';
-
-export class QueryBuilderSetupState {
-  queryBuilderState: QueryBuilderState;
-  _class?: Class | undefined;
-  mapping?: Mapping | undefined;
-  runtimeValue?: Runtime | undefined;
-  classIsReadOnly = false;
-  mappingIsReadOnly = false;
-  runtimeIsReadOnly = false;
-  showSetupPanel = true;
-
-  // 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) {
-    makeAutoObservable(this, {
-      queryBuilderState: false,
-      processingDate: observable,
-      businessDate: observable,
-      setQueryBuilderState: action,
-      setClass: action,
-      setMapping: action,
-      setRuntimeValue: action,
-      setProcessingDate: action,
-      setBusinessDate: action,
-      setShowSetupPanel: action,
-      setClassIsReadOnly: action,
-      setMappingIsReadOnly: action,
-      setRuntimeIsReadOnly: action,
-    });
-
-    this.queryBuilderState = queryBuilderState;
-  }
-
-  private initializeQueryMilestoningParameters(stereotype: string): void {
-    switch (stereotype) {
-      case MILESTONING_STEREOTYPE.BUSINESS_TEMPORAL: {
-        this.setBusinessDate(
-          this.queryBuilderState.buildMilestoningParameter(
-            DEFAULT_BUSINESS_DATE_MILESTONING_PARAMETER_NAME,
-          ),
-        );
-        break;
-      }
-      case MILESTONING_STEREOTYPE.PROCESSING_TEMPORAL: {
-        this.setProcessingDate(
-          this.queryBuilderState.buildMilestoningParameter(
-            DEFAULT_PROCESSING_DATE_MILESTONING_PARAMETER_NAME,
-          ),
-        );
-        break;
-      }
-      case MILESTONING_STEREOTYPE.BITEMPORAL: {
-        this.setProcessingDate(
-          this.queryBuilderState.buildMilestoningParameter(
-            DEFAULT_PROCESSING_DATE_MILESTONING_PARAMETER_NAME,
-          ),
-        );
-        this.setBusinessDate(
-          this.queryBuilderState.buildMilestoningParameter(
-            DEFAULT_BUSINESS_DATE_MILESTONING_PARAMETER_NAME,
-          ),
-        );
-        break;
-      }
-      default:
-    }
-  }
-
-  get classes(): Class[] {
-    return this.queryBuilderState.graphManagerState.graph.ownClasses
-      .concat(
-        this.queryBuilderState.graphManagerState.collectExposedSystemElements(
-          this.queryBuilderState.graphManagerState.graph.systemModel.ownClasses,
-        ),
-      )
-      .concat(
-        this.queryBuilderState.graphManagerState.graph.dependencyManager
-          .classes,
-      );
-  }
-
-  get mappings(): Mapping[] {
-    return this.queryBuilderState.graphManagerState.graph.mappings;
-  }
-
-  private get compatibleMappings(): Mapping[] {
-    const mappingsWithClassMapped = this.mappings.filter((mapping) =>
-      mapping.classMappings.some((cm) => cm.class.value === this._class),
-    );
-    const resolvedMappingIncludes = this.mappings.filter((mapping) =>
-      getAllIncludedMappings(mapping).some((e) =>
-        mappingsWithClassMapped.includes(e),
-      ),
-    );
-    return this._class
-      ? uniq([...mappingsWithClassMapped, ...resolvedMappingIncludes])
-      : [];
-  }
-
-  get compatibleRuntimes(): PackageableRuntime[] {
-    const mapping = this.mapping;
-    // 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
-    return mapping
-      ? this.queryBuilderState.graphManagerState.graph.runtimes.filter(
-          (runtime) =>
-            runtime.runtimeValue.mappings
-              .map((mappingReference) => [
-                mappingReference.value,
-                ...getAllIncludedMappings(mappingReference.value),
-              ])
-              .flat()
-              .includes(mapping),
-        )
-      : [];
-  }
-
-  setQueryBuilderState(queryBuilderState: QueryBuilderState): void {
-    this.queryBuilderState = queryBuilderState;
-  }
-  setRuntimeValue(val: Runtime | undefined): void {
-    this.runtimeValue = val;
-  }
-  setShowSetupPanel(val: boolean): void {
-    this.showSetupPanel = val;
-  }
-  setClassIsReadOnly(val: boolean): void {
-    this.classIsReadOnly = val;
-  }
-  setMappingIsReadOnly(val: boolean): void {
-    this.mappingIsReadOnly = val;
-  }
-  setRuntimeIsReadOnly(val: boolean): void {
-    this.runtimeIsReadOnly = val;
-  }
-
-  setClass(val: Class | undefined, isRebuildingState?: boolean): void {
-    this._class = val;
-    const isMappingEditable = !isRebuildingState && !this.mappingIsReadOnly;
-    const isCurrentMappingCompatible =
-      this.mapping && this.compatibleMappings.includes(this.mapping);
-    if (isMappingEditable && !isCurrentMappingCompatible) {
-      // try to select the first compatible mapping
-      const possibleMapping = getNullableFirstElement(this.compatibleMappings);
-      if (possibleMapping) {
-        this.setMapping(possibleMapping);
-      }
-    }
-    if (val !== undefined) {
-      const stereotype = getMilestoneTemporalStereotype(
-        val,
-        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.setShowParameterPanel(true);
-      }
-    }
-  }
-
-  setMapping(val: Mapping | undefined): void {
-    this.mapping = val;
-    if (this.runtimeIsReadOnly) {
-      return;
-    }
-    const runtimeToPick = getNullableFirstElement(this.compatibleRuntimes);
-    if (runtimeToPick) {
-      this.setRuntimeValue(
-        new RuntimePointer(
-          PackageableElementExplicitReference.create(runtimeToPick),
-        ),
-      );
-    } else {
-      // TODO?: we should consider if we allow users to use custom runtime here
-      this.setRuntimeValue(undefined);
-    }
-  }
-
-  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;
-  }
-}