@finos/legend-application-query 5.2.6 → 6.0.0

package/src/components/query-builder/workflows/ServiceQueryBuilder.tsx

@@ -0,0 +1,192 @@
+/**
+ * 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 {
+  CustomSelectorInput,
+  PURE_MappingIcon,
+  PURE_RuntimeIcon,
+  PlayIcon,
+} from '@finos/legend-art';
+import { observer } from 'mobx-react-lite';
+import { getMappingCompatibleClasses } from '@finos/legend-graph';
+import {
+  getPackageableElementOptionFormatter,
+  buildElementOption,
+  useApplicationStore,
+} from '@finos/legend-application';
+import {
+  buildRuntimeValueOption,
+  getRuntimeOptionFormatter,
+  QueryBuilderClassSelector,
+} from '../QueryBuilderSideBar.js';
+import type {
+  ServiceExecutionContext,
+  ServiceQueryBuilderState,
+} from '../../../stores/query-builder/workflows/ServiceQueryBuilderState.js';
+
+type ExecutionContextOption = {
+  label: string;
+  value: ServiceExecutionContext;
+};
+const buildExecutionContextOption = (
+  value: ServiceExecutionContext,
+): ExecutionContextOption => ({
+  label: value.key,
+  value,
+});
+
+/**
+ * This setup panel supports cascading in order: Execution Context -> Class
+ *
+ * In other words, we will only show:
+ * - For class selector: the list of compatible classes with the selected mapping
+ *
+ * See details on propagation/cascading in {@link ServiceQueryBuilderState}
+ */
+const ServiceQueryBuilderSetupPanelContent = observer(
+  (props: { queryBuilderState: ServiceQueryBuilderState }) => {
+    const { queryBuilderState } = props;
+    const applicationStore = useApplicationStore();
+
+    // mapping
+    const selectedMappingOption = queryBuilderState.mapping
+      ? buildElementOption(queryBuilderState.mapping)
+      : null;
+
+    // runtime
+    const selectedRuntimeOption = queryBuilderState.runtimeValue
+      ? buildRuntimeValueOption(queryBuilderState.runtimeValue)
+      : null;
+
+    // execution context
+    const executionContextOptions = queryBuilderState.executionContexts.map(
+      buildExecutionContextOption,
+    );
+    const selectedExecutionContextOption =
+      queryBuilderState.selectedExecutionContext
+        ? buildExecutionContextOption(
+            queryBuilderState.selectedExecutionContext,
+          )
+        : null;
+    const onExecutionContextOptionChange = (
+      option: ExecutionContextOption,
+    ): void => {
+      if (option.value === queryBuilderState.selectedExecutionContext) {
+        return;
+      }
+      queryBuilderState.setSelectedExecutionContext(option.value);
+      queryBuilderState.propagateExecutionContextChange(option.value);
+      queryBuilderState.onExecutionContextChange?.(option.value);
+    };
+
+    // class
+    const classes = queryBuilderState.mapping
+      ? getMappingCompatibleClasses(
+          queryBuilderState.mapping,
+          queryBuilderState.graphManagerState.usableClasses,
+        )
+      : [];
+
+    return (
+      <>
+        <div className="query-builder__setup__config-group">
+          <div className="query-builder__setup__config-group__header">
+            <div className="query-builder__setup__config-group__header__title">
+              service execution context
+            </div>
+          </div>
+          <div className="query-builder__setup__config-group__content">
+            {/* We will display mapping and runtime selector for single-execution and execution context for multi-execution */}
+            {Boolean(queryBuilderState.executionContexts.length) && (
+              <>
+                <div className="query-builder__setup__config-group__item">
+                  <div
+                    className="btn--sm query-builder__setup__config-group__item__label"
+                    title="execution context"
+                  >
+                    <PlayIcon className="query-builder__setup__service__icon__execution-context" />
+                  </div>
+                  <CustomSelectorInput
+                    className="panel__content__form__section__dropdown query-builder__setup__config-group__item__selector"
+                    placeholder="Choose an execution context..."
+                    options={executionContextOptions}
+                    disabled={executionContextOptions.length <= 1}
+                    onChange={onExecutionContextOptionChange}
+                    value={selectedExecutionContextOption}
+                    darkMode={!applicationStore.TEMPORARY__isLightThemeEnabled}
+                  />
+                </div>
+              </>
+            )}
+            {!queryBuilderState.executionContexts.length && (
+              <>
+                <div className="query-builder__setup__config-group__item">
+                  <div
+                    className="btn--sm query-builder__setup__config-group__item__label"
+                    title="mapping"
+                  >
+                    <PURE_MappingIcon />
+                  </div>
+                  <CustomSelectorInput
+                    className="panel__content__form__section__dropdown query-builder__setup__config-group__item__selector"
+                    disabled={true}
+                    options={[]}
+                    value={selectedMappingOption}
+                    darkMode={!applicationStore.TEMPORARY__isLightThemeEnabled}
+                    formatOptionLabel={getPackageableElementOptionFormatter({
+                      darkMode:
+                        !applicationStore.TEMPORARY__isLightThemeEnabled,
+                    })}
+                  />
+                </div>
+                <div className="query-builder__setup__config-group__item">
+                  <div
+                    className="btn--sm query-builder__setup__config-group__item__label"
+                    title="runtime"
+                  >
+                    <PURE_RuntimeIcon />
+                  </div>
+                  <CustomSelectorInput
+                    className="panel__content__form__section__dropdown query-builder__setup__config-group__item__selector"
+                    disabled={true}
+                    options={[]}
+                    value={selectedRuntimeOption}
+                    darkMode={!applicationStore.TEMPORARY__isLightThemeEnabled}
+                    formatOptionLabel={getRuntimeOptionFormatter({
+                      darkMode:
+                        !applicationStore.TEMPORARY__isLightThemeEnabled,
+                    })}
+                  />
+                </div>
+              </>
+            )}
+          </div>
+        </div>
+        <QueryBuilderClassSelector
+          queryBuilderState={queryBuilderState}
+          classes={classes}
+          noMatchMessage="No compatible class found for specified execution context"
+        />
+      </>
+    );
+  },
+);
+
+export const renderServiceQueryBuilderSetupPanelContent = (
+  queryBuilderState: ServiceQueryBuilderState,
+): React.ReactNode => (
+  <ServiceQueryBuilderSetupPanelContent queryBuilderState={queryBuilderState} />
+);

package/src/graphManager/QueryBuilderSupportedFunctions.ts

@@ -0,0 +1,67 @@
+/**
+ * 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_SUPPORTED_FUNCTIONS {
+  AND = 'meta::pure::functions::boolean::and',
+  EXISTS = 'meta::pure::functions::collection::exists',
+  FILTER = 'meta::pure::functions::collection::filter',
+  GET_ALL = 'meta::pure::functions::collection::getAll',
+  NOT = 'meta::pure::functions::boolean::not',
+  OR = 'meta::pure::functions::boolean::or',
+  TAKE = 'meta::pure::functions::collection::take',
+  SUBTYPE = 'meta::pure::functions::lang::subType',
+
+  // graph-fetch
+  GRAPH_FETCH = 'meta::pure::graphFetch::execution::graphFetch',
+  GRAPH_FETCH_CHECKED = 'meta::pure::graphFetch::execution::graphFetchChecked',
+  SERIALIZE = 'meta::pure::graphFetch::execution::serialize',
+
+  // TDS
+  TDS_FILTER = 'meta::pure::tds::filter',
+  TDS_ASC = 'meta::pure::tds::asc',
+  TDS_DESC = 'meta::pure::tds::desc',
+  TDS_AGG = 'meta::pure::tds::agg',
+  TDS_DISTINCT = 'meta::pure::tds::distinct',
+  TDS_PROJECT = 'meta::pure::tds::project',
+  TDS_GROUP_BY = 'meta::pure::tds::groupBy',
+  TDS_SORT = 'meta::pure::tds::sort',
+  TDS_TAKE = 'meta::pure::tds::take',
+
+  // filter
+  CONTAINS = 'meta::pure::functions::string::contains',
+  ENDS_WITH = 'meta::pure::functions::string::endsWith',
+  EQUAL = 'meta::pure::functions::boolean::equal',
+  GREATER_THAN = 'meta::pure::functions::lang::tests::greaterThan',
+  GREATER_THAN_EQUAL = 'meta::pure::functions::lang::tests::greaterThanEqual',
+  IN = 'meta::pure::functions::collection::in',
+  IS_EMPTY = 'meta::pure::functions::collection::isEmpty',
+  LESS_THAN = 'meta::pure::functions::lang::tests::lessThan',
+  LESS_THAN_EQUAL = 'meta::pure::functions::lang::tests::lessThanEqual',
+  STARTS_WITH = 'meta::pure::functions::string::startsWith',
+  // aggregation
+  AVERAGE = 'meta::pure::functions::math::average',
+  COUNT = 'meta::pure::functions::collection::count',
+  JOIN_STRINGS = 'meta::pure::functions::string::joinStrings',
+  DISTINCT = 'meta::pure::functions::collection::distinct',
+  DATE_MAX = 'meta::pure::functions::date::max',
+  DATE_MIN = 'meta::pure::functions::date::min',
+  MAX = 'meta::pure::functions::math::max',
+  MIN = 'meta::pure::functions::math::min',
+  STD_DEV_POPULATION = 'meta::pure::functions::math::stdDevPopulation',
+  STD_DEV_SAMPLE = 'meta::pure::functions::math::stdDevSample',
+  SUM = 'meta::pure::functions::math::sum',
+  UNIQUE_VALUE_ONLY = 'meta::pure::functions::collection::uniqueValueOnly',
+}

package/src/graphManager/protocol/pure/QueryBuilder_PureProtocolProcessorPlugin.ts

@@ -37,7 +37,7 @@ import {
   V1_buildGenericFunctionExpression,
 } from '@finos/legend-graph';
 import { V1_buildSubTypePropertyExpressionTypeInference } from './v1/V1_QueryBuilder_PropertyExpressionTypeInferenceBuilder.js';
-import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../QueryBuilder_Const.js';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../QueryBuilderSupportedFunctions.js';
 
 export class QueryBuilder_PureProtocolProcessorPlugin extends PureProtocolProcessorPlugin {
   constructor() {
@@ -70,14 +70,10 @@ export class QueryBuilder_PureProtocolProcessorPlugin extends PureProtocolProces
             processingContext,
           );
         } else if (
-          matchFunctionName(
-            functionName,
+          matchFunctionName(functionName, [
             QUERY_BUILDER_SUPPORTED_FUNCTIONS.FILTER,
-          ) ||
-          matchFunctionName(
-            functionName,
             QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_FILTER,
-          )
+          ])
         ) {
           return V1_buildFilterFunctionExpression(
             functionName,
@@ -126,8 +122,9 @@ export class QueryBuilder_PureProtocolProcessorPlugin extends PureProtocolProces
             processingContext,
           );
         } else if (
-          Object.values(QUERY_BUILDER_SUPPORTED_FUNCTIONS).some((fn) =>
-            matchFunctionName(functionName, fn),
+          matchFunctionName(
+            functionName,
+            Object.values(QUERY_BUILDER_SUPPORTED_FUNCTIONS),
           )
         ) {
           // NOTE: this is a catch-all builder that is only meant for basic function expression

package/src/graphManager/protocol/pure/v1/V1_QueryBuilder_FunctionExpressionBuilder.ts

@@ -22,10 +22,6 @@ import {
   guaranteeType,
   returnUndefOnError,
 } from '@finos/legend-shared';
-import {
-  QUERY_BUILDER_SUPPORTED_FUNCTIONS,
-  TDS_ROW,
-} from '../../../../QueryBuilder_Const.js';
 import {
   type V1_GraphBuilderContext,
   type V1_ProcessingContext,
@@ -52,7 +48,9 @@ import {
   AbstractPropertyExpression,
   TYPICAL_MULTIPLICITY_TYPE,
   VariableExpression,
+  CORE_PURE_PATH,
 } from '@finos/legend-graph';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../QueryBuilderSupportedFunctions.js';
 
 const buildProjectionColumnLambda = (
   valueSpecification: V1_ValueSpecification,
@@ -429,7 +427,7 @@ export const V1_buildProjectFunctionExpression = (
     compileContext,
   );
   expression.genericType = GenericTypeExplicitReference.create(
-    new GenericType(compileContext.resolveType(TDS_ROW).value),
+    new GenericType(compileContext.resolveType(CORE_PURE_PATH.TDS_ROW).value),
   );
   return [expression, processedParams];
 };
@@ -567,7 +565,7 @@ export const V1_buildGroupByFunctionExpression = (
     compileContext,
   );
   expression.genericType = GenericTypeExplicitReference.create(
-    new GenericType(compileContext.resolveType(TDS_ROW).value),
+    new GenericType(compileContext.resolveType(CORE_PURE_PATH.TDS_ROW).value),
   );
   return [expression, processedParams];
 };

package/src/index.ts

@@ -18,11 +18,8 @@ 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 +41,18 @@ export {
   LegendQueryBaseStore,
   type LegendQueryApplicationStore,
 } from './stores/LegendQueryBaseStore.js';
+export { LEGEND_QUERY_APP_EVENT } from './LegendQueryAppEvent.js';
+export { LegendQueryEventService } from './stores/LegendQueryEventService.js';
+
+// query builder core
+export { QUERY_BUILDER_TEST_ID } from './components/query-builder/QueryBuilder_TestID.js';
+export { QueryBuilder } from './components/query-builder/QueryBuilder.js';
+export { QueryBuilderState } from './stores/query-builder/QueryBuilderState.js';
+
 export {
-  QueryBuilderMode,
-  StandardQueryBuilderMode,
-  QueryBuilderState,
-} from './stores/QueryBuilderState.js';
+  QueryBuilderClassSelector,
+  buildRuntimeValueOption,
+  getRuntimeOptionFormatter,
+} from './components/query-builder/QueryBuilderSideBar.js';
+export { ClassQueryBuilderState } from './stores/query-builder/workflows/ClassQueryBuilderState.js';
+export { ServiceQueryBuilderState } from './stores/query-builder/workflows/ServiceQueryBuilderState.js';

package/src/stores/LegendQueryApplicationPlugin.ts

@@ -15,8 +15,10 @@
  */
 
 import { LegendApplicationPlugin } from '@finos/legend-application';
+import type { Query } from '@finos/legend-graph';
 import type React from 'react';
 import type { LegendQueryPluginManager } from '../application/LegendQueryPluginManager.js';
+import type { QueryBuilderState } from './query-builder/QueryBuilderState.js';
 import type { QueryEditorStore } from './QueryEditorStore.js';
 import type { QuerySetupState, QuerySetupStore } from './QuerySetupStore.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,
   });