@finos/legend-query-builder 0.0.1

package/src/stores/QueryBuilderResultState.ts

@@ -0,0 +1,281 @@
+/**
+ * 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.unsupportedQueryState.rawLambda,
+        'Lambda is required to execute query',
+      );
+      if (
+        !this.queryBuilderState.isParameterSupportDisabled &&
+        this.queryBuilderState.parametersState.parameterStates.length
+      ) {
+        const letlambdaFunction = buildParametersLetLambdaFunc(
+          this.queryBuilderState.graphManagerState.graph,
+          this.queryBuilderState.parametersState.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.mapping,
+        'Mapping is required to execute query',
+      );
+      const runtime = guaranteeNonNullable(
+        this.queryBuilderState.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.mapping,
+        'Mapping is required to execute query',
+      );
+      const runtime = guaranteeNonNullable(
+        this.queryBuilderState.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.mapping,
+        'Mapping is required to execute query',
+      );
+      const runtime = guaranteeNonNullable(
+        this.queryBuilderState.runtimeValue,
+        `Runtime is required to execute query`,
+      );
+      const query = this.queryBuilderState.buildQuery();
+      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;
+    }
+  }
+}