@finos/legend-application-query 5.2.8 → 7.0.0

package/src/components/QueryEditorComponentTestUtils.tsx

@@ -20,8 +20,7 @@ import { Router } from 'react-router';
 import { createMemoryHistory } from 'history';
 import {
   type TEMPORARY__JestMock,
-  MOBX__disableSpyOrMock,
-  MOBX__enableSpyOrMock,
+  guaranteeNonNullable,
 } from '@finos/legend-shared';
 import {
   type GraphManagerState,
@@ -46,11 +45,14 @@ import { TEST__getTestLegendQueryApplicationConfig } from '../stores/QueryEditor
 import { LegendQueryPluginManager } from '../application/LegendQueryPluginManager.js';
 import { ExistingQueryEditor } from './QueryEditor.js';
 import { generateExistingQueryEditorRoute } from '../stores/LegendQueryRouter.js';
-import { QUERY_BUILDER_TEST_ID } from './QueryBuilder_TestID.js';
 import type { Entity } from '@finos/legend-storage';
 import { ExistingQueryEditorStore } from '../stores/QueryEditorStore.js';
 import { LegendQueryBaseStoreProvider } from './LegendQueryBaseStoreProvider.js';
 import type { LegendQueryApplicationStore } from '../stores/LegendQueryBaseStore.js';
+import {
+  type QueryBuilderState,
+  QUERY_BUILDER_TEST_ID,
+} from '@finos/legend-query-builder';
 
 export const TEST__LegendQueryBaseStoreProvider: React.FC<{
   children: React.ReactNode;
@@ -98,7 +100,10 @@ export const TEST__setUpQueryEditor = async (
   mappingPath: string,
   runtimePath: string,
   rawMappingModelCoverageAnalysisResult?: RawMappingModelCoverageAnalysisResult,
-): Promise<RenderResult> => {
+): Promise<{
+  renderResult: RenderResult;
+  queryBuilderState: QueryBuilderState;
+}> => {
   const projectData = {
     id: 'test-id',
     groupId: 'test.group',
@@ -117,11 +122,12 @@ export const TEST__setUpQueryEditor = async (
   lightQuery.owner = 'test-artifact';
   lightQuery.isCurrentUserQuery = true;
 
-  await MOCK__editorStore.graphManagerState.initializeSystem();
-  await MOCK__editorStore.graphManagerState.graphManager.buildGraph(
-    MOCK__editorStore.graphManagerState.graph,
+  const graphManagerState = MOCK__editorStore.graphManagerState;
+  await graphManagerState.initializeSystem();
+  await graphManagerState.graphManager.buildGraph(
+    graphManagerState.graph,
     entities,
-    MOCK__editorStore.graphManagerState.graphBuildState,
+    graphManagerState.graphBuildState,
   );
 
   const query = new Query();
@@ -133,42 +139,40 @@ export const TEST__setUpQueryEditor = async (
   query.owner = lightQuery.owner;
   query.isCurrentUserQuery = lightQuery.isCurrentUserQuery;
   query.mapping = PackageableElementExplicitReference.create(
-    MOCK__editorStore.graphManagerState.graph.getMapping(mappingPath),
+    graphManagerState.graph.getMapping(mappingPath),
   );
   query.runtime = PackageableElementExplicitReference.create(
-    MOCK__editorStore.graphManagerState.graph.getRuntime(runtimePath),
+    graphManagerState.graph.getRuntime(runtimePath),
   );
   query.content = 'some content';
 
-  MOBX__enableSpyOrMock();
   jest
     .spyOn(MOCK__editorStore.depotServerClient, 'getProject')
-    .mockResolvedValue(projectData);
+    .mockReturnValue(Promise.resolve(projectData));
   jest
-    .spyOn(MOCK__editorStore.graphManagerState.graphManager, 'getLightQuery')
-    .mockResolvedValue(lightQuery);
+    .spyOn(graphManagerState.graphManager, 'getLightQuery')
+    .mockReturnValue(Promise.resolve(lightQuery));
   jest
-    .spyOn(MOCK__editorStore.graphManagerState.graphManager, 'pureCodeToLambda')
-    .mockResolvedValue(new RawLambda(lambda.parameters, lambda.body));
+    .spyOn(graphManagerState.graphManager, 'pureCodeToLambda')
+    .mockReturnValue(
+      Promise.resolve(new RawLambda(lambda.parameters, lambda.body)),
+    );
   jest
-    .spyOn(MOCK__editorStore.graphManagerState.graphManager, 'getQuery')
-    .mockResolvedValue(query);
+    .spyOn(graphManagerState.graphManager, 'getQuery')
+    .mockReturnValue(Promise.resolve(query));
   if (rawMappingModelCoverageAnalysisResult) {
     jest
-      .spyOn(
-        MOCK__editorStore.graphManagerState.graphManager,
-        'analyzeMappingModelCoverage',
-      )
-      .mockResolvedValue(
-        MOCK__editorStore.graphManagerState.graphManager.buildMappingModelCoverageAnalysisResult(
-          rawMappingModelCoverageAnalysisResult,
+      .spyOn(graphManagerState.graphManager, 'analyzeMappingModelCoverage')
+      .mockReturnValue(
+        Promise.resolve(
+          graphManagerState.graphManager.buildMappingModelCoverageAnalysisResult(
+            rawMappingModelCoverageAnalysisResult,
+          ),
         ),
       );
   }
   MOCK__editorStore.buildGraph = jest.fn<TEMPORARY__JestMock>();
-  MOCK__editorStore.graphManagerState.graphManager.initialize =
-    jest.fn<TEMPORARY__JestMock>();
-  MOBX__disableSpyOrMock();
+  graphManagerState.graphManager.initialize = jest.fn<TEMPORARY__JestMock>();
 
   const history = createMemoryHistory({
     initialEntries: [generateExistingQueryEditorRoute(lightQuery.id)],
@@ -194,5 +198,12 @@ export const TEST__setUpQueryEditor = async (
   await waitFor(() =>
     renderResult.getByTestId(QUERY_BUILDER_TEST_ID.QUERY_BUILDER),
   );
-  return renderResult;
+
+  return {
+    renderResult,
+    queryBuilderState: guaranteeNonNullable(
+      MOCK__editorStore.queryBuilderState,
+      `Query builder state should have been initialized`,
+    ),
+  };
 };

package/src/components/QueryEditorStoreProvider.tsx

@@ -19,9 +19,9 @@ import { useLocalObservable } from 'mobx-react-lite';
 import { guaranteeNonNullable } from '@finos/legend-shared';
 import {
   type QueryEditorStore,
-  CreateQueryEditorStore,
+  MappingQueryCreatorStore,
   ExistingQueryEditorStore,
-  ServiceQueryEditorStore,
+  ServiceQueryCreatorStore,
 } from '../stores/QueryEditorStore.js';
 import {
   parseGAVCoordinates,
@@ -59,20 +59,19 @@ export const ExistingQueryEditorStoreProvider: React.FC<{
   );
 };
 
-export const CreateQueryEditorStoreProvider: React.FC<{
+export const MappingQueryCreatorStoreProvider: React.FC<{
   children: React.ReactNode;
   gav: string;
   mappingPath: string;
   runtimePath: string;
-  classPath: string | undefined;
-}> = ({ children, gav, mappingPath, runtimePath, classPath }) => {
+}> = ({ children, gav, mappingPath, runtimePath }) => {
   const { groupId, artifactId, versionId } = parseGAVCoordinates(gav);
   const applicationStore = useLegendQueryApplicationStore();
   const depotServerClient = useDepotServerClient();
   const baseStore = useLegendQueryBaseStore();
   const store = useLocalObservable(
     () =>
-      new CreateQueryEditorStore(
+      new MappingQueryCreatorStore(
         applicationStore,
         depotServerClient,
         baseStore.pluginManager,
@@ -81,7 +80,6 @@ export const CreateQueryEditorStoreProvider: React.FC<{
         versionId,
         mappingPath,
         runtimePath,
-        classPath,
       ),
   );
   return (
@@ -91,7 +89,7 @@ export const CreateQueryEditorStoreProvider: React.FC<{
   );
 };
 
-export const ServiceQueryEditorStoreProvider: React.FC<{
+export const ServiceQueryCreatorStoreProvider: React.FC<{
   children: React.ReactNode;
   gav: string;
   servicePath: string;
@@ -103,7 +101,7 @@ export const ServiceQueryEditorStoreProvider: React.FC<{
   const baseStore = useLegendQueryBaseStore();
   const store = useLocalObservable(
     () =>
-      new ServiceQueryEditorStore(
+      new ServiceQueryCreatorStore(
         applicationStore,
         depotServerClient,
         baseStore.pluginManager,

package/src/components/QuerySetup.tsx

@@ -38,16 +38,16 @@ import { flowResult } from 'mobx';
 import { observer } from 'mobx-react-lite';
 import { Fragment, useEffect, useMemo, useRef, useState } from 'react';
 import {
-  generateCreateQueryEditorRoute,
+  generateMappingQueryCreatorRoute,
   generateExistingQueryEditorRoute,
-  generateServiceQueryEditorRoute,
+  generateServiceQueryCreatorRoute,
 } from '../stores/LegendQueryRouter.js';
 import {
   type QuerySetupState,
   type ServiceExecutionOption,
-  CreateQuerySetupState,
-  ExistingQuerySetupState,
-  ServiceQuerySetupState,
+  CreateMappingQuerySetupState,
+  EditExistingQuerySetupState,
+  LoadServiceQuerySetupState,
 } from '../stores/QuerySetupStore.js';
 import {
   useQuerySetupStore,
@@ -76,8 +76,8 @@ const buildQueryOption = (query: LightQuery): QueryOption => ({
   value: query,
 });
 
-const ExistingQuerySetup = observer(
-  (props: { querySetupState: ExistingQuerySetupState }) => {
+const EditExistingQuerySetup = observer(
+  (props: { querySetupState: EditExistingQuerySetupState }) => {
     const { querySetupState } = props;
     const applicationStore = useApplicationStore();
     const setupStore = useQuerySetupStore();
@@ -273,8 +273,8 @@ const buildVersionOption = (version: string): VersionOption => ({
   value: version,
 });
 
-const ServiceQuerySetup = observer(
-  (props: { querySetupState: ServiceQuerySetupState }) => {
+const LoadServiceQuerySetup = observer(
+  (props: { querySetupState: LoadServiceQuerySetupState }) => {
     const { querySetupState } = props;
     const applicationStore = useApplicationStore();
     const setupStore = useQuerySetupStore();
@@ -290,7 +290,7 @@ const ServiceQuerySetup = observer(
         querySetupState.currentServiceExecutionOption
       ) {
         applicationStore.navigator.goTo(
-          generateServiceQueryEditorRoute(
+          generateServiceQueryCreatorRoute(
             querySetupState.currentProject.groupId,
             querySetupState.currentProject.artifactId,
             querySetupState.currentVersionId,
@@ -510,8 +510,8 @@ const ServiceQuerySetup = observer(
   },
 );
 
-const CreateQuerySetup = observer(
-  (props: { querySetupState: CreateQuerySetupState }) => {
+const CreateMappingQuerySetup = observer(
+  (props: { querySetupState: CreateMappingQuerySetupState }) => {
     const { querySetupState } = props;
     const applicationStore = useApplicationStore();
     const setupStore = useQuerySetupStore();
@@ -528,7 +528,7 @@ const CreateQuerySetup = observer(
         querySetupState.currentRuntime
       ) {
         applicationStore.navigator.goTo(
-          generateCreateQueryEditorRoute(
+          generateMappingQueryCreatorRoute(
             querySetupState.currentProject.groupId,
             querySetupState.currentProject.artifactId,
             querySetupState.currentVersionId,
@@ -805,11 +805,11 @@ const QuerySetupLandingPage = observer(() => {
       <Fragment key={config.key}>{config.renderer(setupStore)}</Fragment>
     ));
   const editQuery = (): void =>
-    setupStore.setSetupState(new ExistingQuerySetupState(setupStore));
+    setupStore.setSetupState(new EditExistingQuerySetupState(setupStore));
   const loadServiceQuery = (): void =>
-    setupStore.setSetupState(new ServiceQuerySetupState(setupStore));
-  const createQuery = (): void =>
-    setupStore.setSetupState(new CreateQuerySetupState(setupStore));
+    setupStore.setSetupState(new LoadServiceQuerySetupState(setupStore));
+  const createMappingQuery = (): void =>
+    setupStore.setSetupState(new CreateMappingQuerySetupState(setupStore));
 
   useEffect(() => {
     setupStore.initialize();
@@ -854,13 +854,13 @@ const QuerySetupLandingPage = observer(() => {
               </button>
               <button
                 className="query-setup__landing-page__option query-setup__landing-page__option--advanced query-setup__landing-page__option--create-query"
-                onClick={createQuery}
+                onClick={createMappingQuery}
               >
                 <div className="query-setup__landing-page__option__icon">
                   <PlusIcon />
                 </div>
                 <div className="query-setup__landing-page__option__label">
-                  Create a new query
+                  Create new query on a mapping
                 </div>
               </button>
             </div>
@@ -878,12 +878,12 @@ export const QuerySetup = withQuerySetupStore(
     const renderQuerySetupScreen = (
       setupState: QuerySetupState,
     ): React.ReactNode => {
-      if (setupState instanceof ExistingQuerySetupState) {
-        return <ExistingQuerySetup querySetupState={setupState} />;
-      } else if (setupState instanceof ServiceQuerySetupState) {
-        return <ServiceQuerySetup querySetupState={setupState} />;
-      } else if (setupState instanceof CreateQuerySetupState) {
-        return <CreateQuerySetup querySetupState={setupState} />;
+      if (setupState instanceof EditExistingQuerySetupState) {
+        return <EditExistingQuerySetup querySetupState={setupState} />;
+      } else if (setupState instanceof LoadServiceQuerySetupState) {
+        return <LoadServiceQuerySetup querySetupState={setupState} />;
+      } else if (setupState instanceof CreateMappingQuerySetupState) {
+        return <CreateMappingQuerySetup querySetupState={setupState} />;
       }
       const extraQuerySetupRenderers = setupStore.pluginManager
         .getApplicationPlugins()

package/src/index.ts

@@ -18,11 +18,6 @@ export * from './application/LegendQuery.js';
 export * from './components/LegendQueryBaseStoreProvider.js';
 export * from './stores/LegendQueryBaseStore.js';
 
-export { QUERY_BUILDER_TEST_ID } from './components/QueryBuilder_TestID.js';
-
-export { QueryBuilder_PureProtocolProcessorPlugin } from './graphManager/protocol/pure/QueryBuilder_PureProtocolProcessorPlugin.js';
-
-export { QueryBuilder } from './components/QueryBuilder.js';
 export {
   QueryEditorStoreContext,
   useQueryEditorStore,
@@ -44,8 +39,5 @@ export {
   LegendQueryBaseStore,
   type LegendQueryApplicationStore,
 } from './stores/LegendQueryBaseStore.js';
-export {
-  QueryBuilderMode,
-  StandardQueryBuilderMode,
-  QueryBuilderState,
-} from './stores/QueryBuilderState.js';
+export { LEGEND_QUERY_APP_EVENT } from './LegendQueryAppEvent.js';
+export { LegendQueryEventService } from './stores/LegendQueryEventService.js';

package/src/stores/LegendQueryApplicationPlugin.ts

@@ -15,6 +15,8 @@
  */
 
 import { LegendApplicationPlugin } from '@finos/legend-application';
+import type { Query } from '@finos/legend-graph';
+import type { QueryBuilderState } from '@finos/legend-query-builder';
 import type React from 'react';
 import type { LegendQueryPluginManager } from '../application/LegendQueryPluginManager.js';
 import type { QueryEditorStore } from './QueryEditorStore.js';
@@ -33,6 +35,11 @@ export type QueryEditorHeaderLabeler = (
   editorStore: QueryEditorStore,
 ) => React.ReactNode | undefined;
 
+export type ExistingQueryEditorStateBuilder = (
+  query: Query,
+  editorStore: QueryEditorStore,
+) => QueryBuilderState | undefined;
+
 export abstract class LegendQueryApplicationPlugin extends LegendApplicationPlugin {
   /**
    * This helps to better type-check for this empty abtract type
@@ -58,4 +65,9 @@ export abstract class LegendQueryApplicationPlugin extends LegendApplicationPlug
    * Get the list of query editor header labelers.
    */
   getExtraQueryEditorHeaderLabelers?(): QueryEditorHeaderLabeler[];
+
+  /**
+   * Get the list of existing query editor state builders.
+   */
+  getExtraExistingQueryEditorStateBuilders?(): ExistingQueryEditorStateBuilder[];
 }

package/src/stores/LegendQueryRouter.ts

@@ -26,25 +26,24 @@ export enum LEGEND_QUERY_PATH_PARAM_TOKEN {
 }
 
 export enum LEGEND_QUERY_QUERY_PARAM_TOKEN {
-  CLASS_PATH = 'class',
   SERVICE_EXECUTION_KEY = 'executionKey',
 }
 
 export const LEGEND_QUERY_ROUTE_PATTERN = Object.freeze({
   SETUP: '/setup',
-  CREATE_QUERY: `/create/:${LEGEND_QUERY_PATH_PARAM_TOKEN.GAV}/:${LEGEND_QUERY_PATH_PARAM_TOKEN.MAPPING_PATH}/:${LEGEND_QUERY_PATH_PARAM_TOKEN.RUNTIME_PATH}`,
-  SERVICE_QUERY: `/service/:${LEGEND_QUERY_PATH_PARAM_TOKEN.GAV}/:${LEGEND_QUERY_PATH_PARAM_TOKEN.SERVICE_PATH}`,
-  EXISTING_QUERY: `/edit/:${LEGEND_QUERY_PATH_PARAM_TOKEN.QUERY_ID}`,
+  CREATE_FROM_MAPPING_QUERY: `/create/manual/:${LEGEND_QUERY_PATH_PARAM_TOKEN.GAV}/:${LEGEND_QUERY_PATH_PARAM_TOKEN.MAPPING_PATH}/:${LEGEND_QUERY_PATH_PARAM_TOKEN.RUNTIME_PATH}`,
+  CREATE_FROM_SERVICE_QUERY: `/create-from-service/:${LEGEND_QUERY_PATH_PARAM_TOKEN.GAV}/:${LEGEND_QUERY_PATH_PARAM_TOKEN.SERVICE_PATH}`,
+  EDIT_EXISTING_QUERY: `/edit/:${LEGEND_QUERY_PATH_PARAM_TOKEN.QUERY_ID}`,
 });
 
-export const generateCreateQueryEditorRoute = (
+export const generateMappingQueryCreatorRoute = (
   groupId: string,
   artifactId: string,
   versionId: string,
   mappingPath: string,
   runtimePath: string,
 ): string =>
-  generatePath(LEGEND_QUERY_ROUTE_PATTERN.CREATE_QUERY, {
+  generatePath(LEGEND_QUERY_ROUTE_PATTERN.CREATE_FROM_MAPPING_QUERY, {
     [LEGEND_QUERY_PATH_PARAM_TOKEN.GAV]: generateGAVCoordinates(
       groupId,
       artifactId,
@@ -54,24 +53,20 @@ export const generateCreateQueryEditorRoute = (
     [LEGEND_QUERY_PATH_PARAM_TOKEN.RUNTIME_PATH]: runtimePath,
   });
 
-export interface CreateQueryPathParams {
+export interface MappingQueryCreatorPathParams {
   [LEGEND_QUERY_PATH_PARAM_TOKEN.GAV]: string;
   [LEGEND_QUERY_PATH_PARAM_TOKEN.MAPPING_PATH]: string;
   [LEGEND_QUERY_PATH_PARAM_TOKEN.RUNTIME_PATH]: string;
 }
 
-export interface CreateQueryEditorQueryParams {
-  [LEGEND_QUERY_QUERY_PARAM_TOKEN.CLASS_PATH]?: string;
-}
-
-export const generateServiceQueryEditorRoute = (
+export const generateServiceQueryCreatorRoute = (
   groupId: string,
   artifactId: string,
   versionId: string,
   servicePath: string,
   key?: string,
 ): string =>
-  `${generatePath(LEGEND_QUERY_ROUTE_PATTERN.SERVICE_QUERY, {
+  `${generatePath(LEGEND_QUERY_ROUTE_PATTERN.CREATE_FROM_SERVICE_QUERY, {
     [LEGEND_QUERY_PATH_PARAM_TOKEN.GAV]: generateGAVCoordinates(
       groupId,
       artifactId,
@@ -82,17 +77,17 @@ export const generateServiceQueryEditorRoute = (
     key ? `?${LEGEND_QUERY_QUERY_PARAM_TOKEN.SERVICE_EXECUTION_KEY}=${key}` : ''
   }`;
 
-export interface ServiceQueryEditorPathParams {
+export interface ServiceQueryCreatorPathParams {
   [LEGEND_QUERY_PATH_PARAM_TOKEN.GAV]: string;
   [LEGEND_QUERY_PATH_PARAM_TOKEN.SERVICE_PATH]: string;
 }
 
-export interface ServiceQueryEditorQueryParams {
+export interface ServiceQueryCreatorQueryParams {
   [LEGEND_QUERY_QUERY_PARAM_TOKEN.SERVICE_EXECUTION_KEY]?: string;
 }
 
 export const generateExistingQueryEditorRoute = (queryId: string): string =>
-  generatePath(LEGEND_QUERY_ROUTE_PATTERN.EXISTING_QUERY, {
+  generatePath(LEGEND_QUERY_ROUTE_PATTERN.EDIT_EXISTING_QUERY, {
     [LEGEND_QUERY_PATH_PARAM_TOKEN.QUERY_ID]: queryId,
   });