@finos/legend-application-query 5.2.6 → 6.0.0

package/src/stores/QueryEditorStore.ts

@@ -33,6 +33,7 @@ import {
   ActionState,
   StopWatch,
   getNullableFirstElement,
+  guaranteeType,
 } from '@finos/legend-shared';
 import {
   type LightQuery,
@@ -42,8 +43,6 @@ import {
   toLightQuery,
   Query,
   PureExecution,
-  PureMultiExecution,
-  PureSingleExecution,
   PackageableElementExplicitReference,
   RuntimePointer,
   GRAPH_MANAGER_EVENT,
@@ -51,12 +50,15 @@ import {
   GraphManagerTelemetry,
   extractElementNameFromPath,
   isSystemElement,
+  Mapping,
+  type Runtime,
 } from '@finos/legend-graph';
+import type { QueryBuilderState } from './query-builder/QueryBuilderState.js';
 import {
-  QueryBuilderState,
-  StandardQueryBuilderMode,
-} from './QueryBuilderState.js';
-import { generateExistingQueryEditorRoute } from './LegendQueryRouter.js';
+  generateExistingQueryEditorRoute,
+  generateMappingQueryCreatorRoute,
+  generateServiceQueryCreatorRoute,
+} from './LegendQueryRouter.js';
 import { LEGEND_QUERY_APP_EVENT } from '../LegendQueryAppEvent.js';
 import type { Entity } from '@finos/legend-storage';
 import {
@@ -68,6 +70,12 @@ import { TAB_SIZE, APPLICATION_EVENT } from '@finos/legend-application';
 import type { LegendQueryPluginManager } from '../application/LegendQueryPluginManager.js';
 import { LegendQueryEventService } from './LegendQueryEventService.js';
 import type { LegendQueryApplicationStore } from './LegendQueryBaseStore.js';
+import { ClassQueryBuilderState } from './query-builder/workflows/ClassQueryBuilderState.js';
+import { MappingQueryBuilderState } from './query-builder/workflows/MappingQueryBuilderState.js';
+import {
+  type ServiceExecutionContext,
+  ServiceQueryBuilderState,
+} from './query-builder/workflows/ServiceQueryBuilderState.js';
 
 export interface QueryExportConfiguration {
   defaultName?: string | undefined;
@@ -83,10 +91,12 @@ export class QueryExportState {
   allowUpdate = false;
   onQueryUpdate?: ((query: Query) => void) | undefined;
   decorator?: ((query: Query) => void) | undefined;
+  queryBuilderState: QueryBuilderState;
   persistQueryState = ActionState.create();
 
   constructor(
     editorStore: QueryEditorStore,
+    queryBuilderState: QueryBuilderState,
     lambda: RawLambda,
     config: QueryExportConfiguration,
   ) {
@@ -97,6 +107,7 @@ export class QueryExportState {
     });
 
     this.editorStore = editorStore;
+    this.queryBuilderState = queryBuilderState;
     this.lambda = lambda;
     this.allowUpdate = config.allowUpdate ?? false;
     this.queryName = config.defaultName ?? 'New Query';
@@ -111,19 +122,15 @@ export class QueryExportState {
   get allowPersist(): boolean {
     return (
       !this.persistQueryState.isInProgress &&
-      Boolean(this.editorStore.queryBuilderState.querySetupState.mapping) &&
-      this.editorStore.queryBuilderState.querySetupState.runtimeValue instanceof
-        RuntimePointer
+      Boolean(this.queryBuilderState.mapping) &&
+      this.queryBuilderState.runtimeValue instanceof RuntimePointer
     );
   }
 
   async persistQuery(createNew: boolean): Promise<void> {
     if (
-      !this.editorStore.queryBuilderState.querySetupState.mapping ||
-      !(
-        this.editorStore.queryBuilderState.querySetupState
-          .runtimeValue instanceof RuntimePointer
-      )
+      !this.queryBuilderState.mapping ||
+      !(this.queryBuilderState.runtimeValue instanceof RuntimePointer)
     ) {
       return;
     }
@@ -131,10 +138,9 @@ export class QueryExportState {
     const query = new Query();
     query.name = this.queryName;
     query.mapping = PackageableElementExplicitReference.create(
-      this.editorStore.queryBuilderState.querySetupState.mapping,
+      this.queryBuilderState.mapping,
     );
-    query.runtime =
-      this.editorStore.queryBuilderState.querySetupState.runtimeValue.packageableRuntime;
+    query.runtime = this.queryBuilderState.runtimeValue.packageableRuntime;
     this.decorator?.(query);
     try {
       query.content =
@@ -203,7 +209,7 @@ export abstract class QueryEditorStore {
   graphManagerState: GraphManagerState;
 
   initState = ActionState.create();
-  queryBuilderState: QueryBuilderState;
+  queryBuilderState?: QueryBuilderState | undefined;
   exportState?: QueryExportState | undefined;
 
   constructor(
@@ -225,11 +231,6 @@ export abstract class QueryEditorStore {
       this.pluginManager,
       this.applicationStore.log,
     );
-    this.queryBuilderState = new QueryBuilderState(
-      this.applicationStore,
-      this.graphManagerState,
-      new StandardQueryBuilderMode(),
-    );
   }
 
   setExportState(val: QueryExportState | undefined): void {
@@ -246,7 +247,7 @@ export abstract class QueryEditorStore {
   /**
    * Set up the query builder state after building the graph
    */
-  protected abstract setUpBuilderState(): Promise<void>;
+  protected abstract initializeQueryBuilderState(): Promise<QueryBuilderState>;
   abstract getExportConfiguration(
     lambda: RawLambda,
   ): Promise<QueryExportConfiguration>;
@@ -289,7 +290,8 @@ export abstract class QueryEditorStore {
       yield this.setUpEditorState();
       const { groupId, artifactId, versionId } = this.getProjectInfo();
       yield flowResult(this.buildGraph(groupId, artifactId, versionId));
-      yield this.setUpBuilderState();
+      this.queryBuilderState =
+        (yield this.initializeQueryBuilderState()) as QueryBuilderState;
 
       this.initState.pass();
     } catch (error) {
@@ -393,13 +395,12 @@ export abstract class QueryEditorStore {
   }
 }
 
-export class CreateQueryEditorStore extends QueryEditorStore {
+export class MappingQueryCreatorStore extends QueryEditorStore {
   groupId: string;
   artifactId: string;
   versionId: string;
   mappingPath: string;
   runtimePath: string;
-  classPath: string | undefined;
 
   constructor(
     applicationStore: LegendQueryApplicationStore,
@@ -410,7 +411,6 @@ export class CreateQueryEditorStore extends QueryEditorStore {
     versionId: string,
     mappingPath: string,
     runtimePath: string,
-    classPath: string | undefined,
   ) {
     super(applicationStore, depotServerClient, pluginManager);
 
@@ -419,7 +419,6 @@ export class CreateQueryEditorStore extends QueryEditorStore {
     this.versionId = versionId;
     this.mappingPath = mappingPath;
     this.runtimePath = runtimePath;
-    this.classPath = classPath;
   }
 
   getProjectInfo(): ProjectGAVCoordinates {
@@ -430,50 +429,72 @@ export class CreateQueryEditorStore extends QueryEditorStore {
     };
   }
 
-  async setUpBuilderState(): Promise<void> {
-    this.queryBuilderState.querySetupState.setMappingIsReadOnly(true);
-    this.queryBuilderState.querySetupState.setRuntimeIsReadOnly(true);
-    this.queryBuilderState.querySetupState.setMapping(
-      this.graphManagerState.graph.getMapping(this.mappingPath),
+  async initializeQueryBuilderState(): Promise<QueryBuilderState> {
+    const queryBuilderState = new MappingQueryBuilderState(
+      this.applicationStore,
+      this.graphManagerState,
+      (val: Mapping) => {
+        this.applicationStore.navigator.goTo(
+          generateMappingQueryCreatorRoute(
+            this.groupId,
+            this.artifactId,
+            this.versionId,
+            val.path,
+            guaranteeType(queryBuilderState.runtimeValue, RuntimePointer)
+              .packageableRuntime.value.path,
+          ),
+        );
+      },
+      (val: Runtime) => {
+        this.applicationStore.navigator.goTo(
+          generateMappingQueryCreatorRoute(
+            this.groupId,
+            this.artifactId,
+            this.versionId,
+            guaranteeType(queryBuilderState.mapping, Mapping).path,
+            guaranteeType(val, RuntimePointer).packageableRuntime.value.path,
+          ),
+        );
+      },
     );
-    this.queryBuilderState.querySetupState.setRuntimeValue(
+
+    const mapping = this.graphManagerState.graph.getMapping(this.mappingPath);
+    queryBuilderState.changeMapping(mapping);
+    queryBuilderState.propagateMappingChange(mapping);
+    queryBuilderState.changeRuntime(
       new RuntimePointer(
         PackageableElementExplicitReference.create(
           this.graphManagerState.graph.getRuntime(this.runtimePath),
         ),
       ),
     );
-    if (this.classPath) {
-      this.queryBuilderState.changeClass(
-        this.queryBuilderState.graphManagerState.graph.getClass(this.classPath),
+
+    // try to find a class to set
+    // first, find classes which is mapped by the mapping
+    // then, find any classes except for class coming from system
+    // if none found, default to a dummy blank query
+    const defaultClass =
+      getNullableFirstElement(
+        queryBuilderState.mapping
+          ? getAllClassMappings(queryBuilderState.mapping).map(
+              (classMapping) => classMapping.class.value,
+            )
+          : [],
+      ) ??
+      getNullableFirstElement(
+        queryBuilderState.graphManagerState.graph.classes.filter(
+          (el) => !isSystemElement(el),
+        ),
       );
-      this.queryBuilderState.querySetupState.setClassIsReadOnly(true);
+    if (defaultClass) {
+      queryBuilderState.changeClass(defaultClass);
     } else {
-      // try to find a class to set
-      // first, find classes which is mapped by the mapping
-      // then, find any classes except for class coming from system
-      // if none found, default to a dummy blank query
-      const defaultClass =
-        getNullableFirstElement(
-          this.queryBuilderState.querySetupState.mapping
-            ? getAllClassMappings(
-                this.queryBuilderState.querySetupState.mapping,
-              ).map((classMapping) => classMapping.class.value)
-            : [],
-        ) ??
-        getNullableFirstElement(
-          this.queryBuilderState.graphManagerState.graph.classes.filter(
-            (el) => !isSystemElement(el),
-          ),
-        );
-      if (defaultClass) {
-        this.queryBuilderState.changeClass(defaultClass);
-      } else {
-        this.queryBuilderState.initialize(
-          this.queryBuilderState.graphManagerState.graphManager.createDefaultBasicRawLambda(),
-        );
-      }
+      queryBuilderState.initialize(
+        this.graphManagerState.graphManager.createDefaultBasicRawLambda(),
+      );
     }
+
+    return queryBuilderState;
   }
 
   async getExportConfiguration(): Promise<QueryExportConfiguration> {
@@ -488,7 +509,7 @@ export class CreateQueryEditorStore extends QueryEditorStore {
   }
 }
 
-export class ServiceQueryEditorStore extends QueryEditorStore {
+export class ServiceQueryCreatorStore extends QueryEditorStore {
   groupId: string;
   artifactId: string;
   versionId: string;
@@ -522,49 +543,36 @@ export class ServiceQueryEditorStore extends QueryEditorStore {
     };
   }
 
-  async setUpBuilderState(): Promise<void> {
-    this.queryBuilderState.querySetupState.setMappingIsReadOnly(true);
-    this.queryBuilderState.querySetupState.setRuntimeIsReadOnly(true);
-
+  async initializeQueryBuilderState(): Promise<QueryBuilderState> {
     const service = this.graphManagerState.graph.getService(this.servicePath);
     assertType(
       service.execution,
       PureExecution,
       `Can't process service execution: only Pure execution is supported`,
     );
-    if (this.executionKey) {
-      assertType(
-        service.execution,
-        PureMultiExecution,
-        `Can't process service execution: an execution key is provided, expecting Pure multi execution`,
-      );
-      const serviceExecution = guaranteeNonNullable(
-        service.execution.executionParameters.find(
-          (parameter) => parameter.key === this.executionKey,
-        ),
-        `Can't process service execution: execution with key '${this.executionKey}' is not found`,
-      );
-      this.queryBuilderState.querySetupState.setMapping(
-        serviceExecution.mapping.value,
-      );
-      this.queryBuilderState.querySetupState.setRuntimeValue(
-        serviceExecution.runtime,
-      );
-    } else {
-      assertType(
-        service.execution,
-        PureSingleExecution,
-        `Can't process service execution: no execution key is provided, expecting Pure single execution`,
-      );
-      this.queryBuilderState.querySetupState.setMapping(
-        service.execution.mapping.value,
-      );
-      this.queryBuilderState.querySetupState.setRuntimeValue(
-        service.execution.runtime,
-      );
-    }
+
+    const queryBuilderState = new ServiceQueryBuilderState(
+      this.applicationStore,
+      this.graphManagerState,
+      service,
+      this.executionKey,
+      (val: ServiceExecutionContext): void => {
+        this.applicationStore.navigator.goTo(
+          generateServiceQueryCreatorRoute(
+            this.groupId,
+            this.artifactId,
+            this.versionId,
+            service.path,
+            val.key,
+          ),
+        );
+      },
+    );
+
     // leverage initialization of query builder state to ensure we handle unsupported queries
-    this.queryBuilderState.initialize(service.execution.func);
+    queryBuilderState.initialize(service.execution.func);
+
+    return queryBuilderState;
   }
 
   async getExportConfiguration(): Promise<QueryExportConfiguration> {
@@ -625,24 +633,42 @@ export class ExistingQueryEditorStore extends QueryEditorStore {
     );
   }
 
-  async setUpBuilderState(): Promise<void> {
-    this.queryBuilderState.querySetupState.setMappingIsReadOnly(true);
-    this.queryBuilderState.querySetupState.setRuntimeIsReadOnly(true);
-
+  async initializeQueryBuilderState(): Promise<QueryBuilderState> {
     const query = await this.graphManagerState.graphManager.getQuery(
       this.queryId,
       this.graphManagerState.graph,
     );
-    this.queryBuilderState.querySetupState.setMapping(query.mapping.value);
-    this.queryBuilderState.querySetupState.setRuntimeValue(
+    let queryBuilderState: QueryBuilderState | undefined;
+    const existingQueryEditorStateBuilders = this.applicationStore.pluginManager
+      .getApplicationPlugins()
+      .flatMap(
+        (plugin) => plugin.getExtraExistingQueryEditorStateBuilders?.() ?? [],
+      );
+    for (const builder of existingQueryEditorStateBuilders) {
+      queryBuilderState = builder(query, this);
+      if (queryBuilderState) {
+        break;
+      }
+    }
+
+    // if no extension found, fall back to basic `class -> mapping -> runtime` mode
+    queryBuilderState =
+      queryBuilderState ??
+      new ClassQueryBuilderState(this.applicationStore, this.graphManagerState);
+
+    queryBuilderState.setMapping(query.mapping.value);
+    queryBuilderState.setRuntimeValue(
       new RuntimePointer(
         PackageableElementExplicitReference.create(query.runtime.value),
       ),
     );
+
     // leverage initialization of query builder state to ensure we handle unsupported queries
-    this.queryBuilderState.initialize(
+    queryBuilderState.initialize(
       await this.graphManagerState.graphManager.pureCodeToLambda(query.content),
     );
+
+    return queryBuilderState;
   }
 
   async getExportConfiguration(): Promise<QueryExportConfiguration> {

package/src/stores/QuerySetupStore.ts

@@ -58,7 +58,7 @@ export abstract class QuerySetupState {
   }
 }
 
-export class ExistingQuerySetupState extends QuerySetupState {
+export class EditExistingQuerySetupState extends QuerySetupState {
   queries: LightQuery[] = [];
   loadQueriesState = ActionState.create();
   loadQueryState = ActionState.create();
@@ -125,7 +125,7 @@ export class ExistingQuerySetupState extends QuerySetupState {
   }
 }
 
-export class CreateQuerySetupState extends QuerySetupState {
+export class CreateMappingQuerySetupState extends QuerySetupState {
   projects: ProjectData[] = [];
   loadProjectsState = ActionState.create();
   surveyMappingRuntimeCompatibilityState = ActionState.create();
@@ -240,7 +240,7 @@ export interface ServiceExecutionOption {
   key?: string | undefined;
 }
 
-export class ServiceQuerySetupState extends QuerySetupState {
+export class LoadServiceQuerySetupState extends QuerySetupState {
   projects: ProjectData[] = [];
   loadProjectsState = ActionState.create();
   loadServiceExecutionsState = ActionState.create();

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

@@ -0,0 +1,37 @@
+/**
+ * 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

@@ -0,0 +1,34 @@
+/**
+ * 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

@@ -0,0 +1,54 @@
+/**
+ * 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}'`,
+  );
+};