@finos/legend-query-builder 3.2.10 → 4.0.0

package/lib/stores/workflows/MappingQueryBuilderState.js

@@ -28,10 +28,10 @@ export class MappingQueryBuilderState extends QueryBuilderState {
     }
     /**
      * Propagation after changing the mapping:
-     * - If no runtime is selected, try to select a compatible runtime
-     * - If the chosen runtime is compatible with the new selected mapping, do nothing, otherwise, try to select a compatible runtime
-     * - If no class is selected, try to select a compatible class
-     * - If the chosen class is compatible with the new selected mapping, do nothing, otherwise, try to select a compatible class
+     * - If no runtime is chosen, try to choose a compatible runtime
+     * - If the chosen runtime is compatible with the new chosen mapping, do nothing, otherwise, try to choose a compatible runtime
+     * - If no class is chosen, try to choose a compatible class
+     * - If the chosen class is compatible with the new chosen mapping, do nothing, otherwise, try to choose a compatible class
      */
     propagateMappingChange(mapping) {
         // try to select the first compatible runtime,

package/lib/stores/workflows/ServiceQueryBuilderState.d.ts

@@ -38,8 +38,8 @@ export declare class ServiceQueryBuilderState extends QueryBuilderState {
      * Propagation after changing the execution context:
      * - The mapping will be updated to the mapping of the execution context
      * - The runtime will be updated to the default runtime of the execution context
-     * - If no class is selected, try to select a compatible class
-     * - If the chosen class is compatible with the new selected mapping, do nothing, otherwise, try to select a compatible class
+     * - If no class is chosen, try to choose a compatible class
+     * - If the chosen class is compatible with the new chosen mapping, do nothing, otherwise, try to choose a compatible class
      */
     propagateExecutionContextChange(executionContext: ServiceExecutionContext): void;
 }

package/lib/stores/workflows/ServiceQueryBuilderState.js

@@ -82,8 +82,8 @@ export class ServiceQueryBuilderState extends QueryBuilderState {
      * Propagation after changing the execution context:
      * - The mapping will be updated to the mapping of the execution context
      * - The runtime will be updated to the default runtime of the execution context
-     * - If no class is selected, try to select a compatible class
-     * - If the chosen class is compatible with the new selected mapping, do nothing, otherwise, try to select a compatible class
+     * - If no class is chosen, try to choose a compatible class
+     * - If the chosen class is compatible with the new chosen mapping, do nothing, otherwise, try to choose a compatible class
      */
     propagateExecutionContextChange(executionContext) {
         const mapping = executionContext.mapping;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@finos/legend-query-builder",
-  "version": "3.2.10",
+  "version": "4.0.0",
   "description": "Legend query builder core",
   "keywords": [
     "legend",
@@ -42,13 +42,13 @@
     "test:watch": "jest --watch"
   },
   "dependencies": {
-    "@finos/legend-application": "15.0.14",
-    "@finos/legend-art": "7.0.15",
-    "@finos/legend-graph": "29.0.1",
-    "@finos/legend-lego": "1.0.8",
-    "@finos/legend-server-depot": "6.0.7",
-    "@finos/legend-shared": "10.0.6",
-    "@finos/legend-storage": "3.0.56",
+    "@finos/legend-application": "15.0.15",
+    "@finos/legend-art": "7.0.16",
+    "@finos/legend-graph": "29.0.3",
+    "@finos/legend-lego": "1.0.10",
+    "@finos/legend-server-depot": "6.0.8",
+    "@finos/legend-shared": "10.0.7",
+    "@finos/legend-storage": "3.0.57",
     "@testing-library/react": "14.0.0",
     "@types/react": "18.2.6",
     "@types/react-dom": "18.2.4",
@@ -65,13 +65,13 @@
     "sql-formatter": "12.2.0"
   },
   "devDependencies": {
-    "@finos/legend-dev-utils": "2.0.61",
+    "@finos/legend-dev-utils": "2.0.62",
     "@jest/globals": "29.5.0",
     "cross-env": "7.0.3",
     "eslint": "8.40.0",
     "jest": "29.5.0",
     "npm-run-all": "4.1.5",
-    "rimraf": "5.0.0",
+    "rimraf": "5.0.1",
     "sass": "1.62.1",
     "typescript": "5.0.4"
   },

package/src/components/QueryBuilderPropertyExpressionEditor.tsx

@@ -311,16 +311,15 @@ export const QueryBuilderPropertyExpressionEditor = observer(
     ): boolean =>
       Boolean(
         derivedProperties.find((dp) => {
-          if (!variable.genericType?.value.rawType) {
+          const variableType = variable.genericType?.value.rawType;
+          if (!variableType) {
             return false;
           }
-          return (
-            isSuperType(
-              dp.derivedProperty.genericType.value.rawType,
-              variable.genericType.value.rawType,
-            ) ||
-            dp.derivedProperty.genericType.value.rawType.name ===
-              variable.genericType.value.rawType.name
+          return dp.parameters.some(
+            (p) =>
+              p.genericType &&
+              (isSuperType(variableType, p.genericType.value.rawType) ||
+                p.genericType.value.rawType.name === variableType.name),
           );
         }),
       );

package/src/components/QueryBuilderTextEditor.tsx

@@ -101,10 +101,7 @@ export const QueryBuilderTextEditor = observer(
                   disabled={queryTextEditorState.isConvertingLambdaToString}
                   lambdaEditorState={queryTextEditorState}
                   forceBackdrop={false}
-                  forceExpansion={true}
-                  useBaseTextEditorSettings={true}
-                  hideErrorBar={true}
-                  disablePopUp={true}
+                  autoFocus={true}
                 />
               )}
               {mode === QueryBuilderTextEditorMode.JSON && (

package/src/components/explorer/QueryBuilderFunctionsExplorerPanel.tsx

@@ -157,7 +157,9 @@ const QueryBuilderFunctionsExplorerListEntry = observer(
       element,
       rootPackageName,
     );
-    const functionPrettyName = generateFunctionPrettyName(element, true);
+    const functionPrettyName = generateFunctionPrettyName(element, {
+      fullPath: true,
+    });
     const [, dragConnector, dragPreviewConnector] = useDrag(
       () => ({
         type: QUERY_BUILDER_FUNCTION_DND_TYPE,
@@ -212,7 +214,7 @@ const QueryBuilderFunctionsExplorerTreeNodeContainer = observer(
     const isPackage = node.packageableElement instanceof Package;
     const name =
       node.packageableElement instanceof ConcreteFunctionDefinition
-        ? generateFunctionPrettyName(node.packageableElement, false)
+        ? generateFunctionPrettyName(node.packageableElement)
         : node.packageableElement.name;
     const isExpandable = Boolean(node.childrenIds.length);
     const nodeExpandIcon = isExpandable ? (
@@ -484,7 +486,7 @@ export const QueryBuilderFunctionsExplorerPanel = observer(
             ): string =>
               generateFunctionPrettyName(
                 item.node.packageableElement as ConcreteFunctionDefinition,
-                true,
+                { fullPath: true },
               )
             }
             types={[QUERY_BUILDER_FUNCTION_DND_TYPE]}

package/src/components/fetch-structure/QueryBuilderTDSPanel.tsx

@@ -86,7 +86,7 @@ import {
 import { DEFAULT_LAMBDA_VARIABLE_NAME } from '../../stores/QueryBuilderConfig.js';
 import type { QueryBuilderAggregateOperator } from '../../stores/fetch-structure/tds/aggregation/QueryBuilderAggregateOperator.js';
 import type { QueryBuilderTDSState } from '../../stores/fetch-structure/tds/QueryBuilderTDSState.js';
-import { LambdaEditor } from '../shared/LambdaEditor.js';
+import { InlineLambdaEditor } from '../shared/LambdaEditor.js';
 import {
   type QueryBuilderVariableDragSource,
   QUERY_BUILDER_VARIABLE_DND_TYPE,
@@ -235,7 +235,7 @@ const QueryBuilderDerivationProjectionColumnEditor = observer(
           { backdrop__element: hasParserError },
         )}
       >
-        <LambdaEditor
+        <InlineLambdaEditor
           className="query-builder__lambda-editor"
           disabled={
             projectionColumnState.tdsState.isConvertDerivationProjectionObjects

package/src/components/shared/BasicValueSpecificationEditor.tsx

@@ -906,6 +906,7 @@ export const BasicValueSpecificationEditor: React.FC<{
       case PRIMITIVE_TYPE.FLOAT:
       case PRIMITIVE_TYPE.DECIMAL:
       case PRIMITIVE_TYPE.BINARY:
+      case PRIMITIVE_TYPE.BYTE:
       case PRIMITIVE_TYPE.INTEGER:
         return (
           <NumberPrimitiveInstanceValueEditor

package/src/components/shared/LambdaEditor.tsx

@@ -54,7 +54,7 @@ import {
 } from '@finos/legend-application';
 import { QUERY_BUILDER_TEST_ID } from '../../__lib__/QueryBuilderTesting.js';
 
-const LambdaErrorFeedback: React.FC<{
+const LambdaEditor_ErrorFeedback: React.FC<{
   error?: EngineError | undefined;
   discardChanges: () => void;
 }> = (props) => {
@@ -83,23 +83,24 @@ const LambdaErrorFeedback: React.FC<{
   );
 };
 
-const LambdaEditorInline = observer(
+const LambdaEditor_Inner = observer(
   (props: {
     className?: string | undefined;
     disabled: boolean;
+    inline?: boolean | undefined;
     lambdaEditorState: LambdaEditorState;
     transformStringToLambda: DebouncedFunc<() => GeneratorFn<void>> | undefined;
     expectedType?: Type | undefined;
     matchedExpectedType?: (() => boolean) | undefined;
     onExpectedTypeLabelSelect?: (() => void) | undefined;
-    useBaseTextEditorSettings?: boolean | undefined;
     hideErrorBar?: boolean | undefined;
     forceBackdrop: boolean;
-    disableExpansion?: boolean | undefined;
-    forceExpansion?: boolean | undefined;
     disablePopUp?: boolean | undefined;
-    openInPopUp: () => void;
+    autoFocus?: boolean | undefined;
+    openInPopUp?: (() => void) | undefined;
     onEditorFocus?: (() => void) | undefined;
+    disableExpansion?: boolean | undefined;
+    forceExpansion?: boolean | undefined;
   }) => {
     const {
       className,
@@ -113,8 +114,9 @@ const LambdaEditorInline = observer(
       disableExpansion,
       forceExpansion,
       disablePopUp,
-      useBaseTextEditorSettings,
+      inline,
       hideErrorBar,
+      autoFocus,
       openInPopUp,
       onEditorFocus,
     } = props;
@@ -157,9 +159,8 @@ const LambdaEditorInline = observer(
       if (!editor && textInputRef.current) {
         const element = textInputRef.current;
         const lambdaEditorOptions: monacoEditorAPI.IStandaloneEditorConstructionOptions =
-          useBaseTextEditorSettings
-            ? {}
-            : {
+          inline
+            ? {
                 renderLineHighlight: 'none',
                 lineHeight: 24,
                 overviewRulerBorder: false, // hide overview ruler (no current way to hide this completely yet)
@@ -173,6 +174,9 @@ const LambdaEditorInline = observer(
                 lineDecorationsWidth: 5,
                 snippetSuggestions: 'none',
                 scrollbar: { vertical: 'hidden' },
+              }
+            : {
+                padding: { top: 20, bottom: 20 },
               };
         const _editor = monacoEditorAPI.create(element, {
           ...getBaseCodeEditorOptions(),
@@ -185,7 +189,7 @@ const LambdaEditorInline = observer(
         });
         setEditor(_editor);
       }
-    }, [editor, applicationStore, useBaseTextEditorSettings]);
+    }, [editor, applicationStore, inline]);
 
     // set styling for expanded mode
     useEffect(() => {
@@ -313,6 +317,13 @@ const LambdaEditorInline = observer(
       }
     }
 
+    // auto-focus
+    useEffect(() => {
+      if (editor && autoFocus) {
+        editor.focus();
+      }
+    }, [autoFocus, editor]);
+
     // dispose editor
     useEffect(
       () => (): void => {
@@ -388,14 +399,14 @@ const LambdaEditorInline = observer(
               onClick={openInPopUp}
               disabled={Boolean(parserError)}
               tabIndex={-1}
-              title="Open..."
+              title="Open in a popup..."
             >
               <FilledWindowMaximizeIcon />
             </button>
           )}
         </div>
         {!hideErrorBar && (
-          <LambdaErrorFeedback
+          <LambdaEditor_ErrorFeedback
             error={parserError ?? compilationError}
             discardChanges={discardChanges}
           />
@@ -405,7 +416,7 @@ const LambdaEditorInline = observer(
   },
 );
 
-const LambdaEditorPopUp = observer(
+const LambdaEditor_PopUp = observer(
   (props: {
     className?: string | undefined;
     disabled: boolean;
@@ -625,63 +636,61 @@ const LambdaEditorPopUp = observer(
   },
 );
 
-/**
- * This is not strictly meant for lambda. The idea is to create an editor that allows
- * editing _something_ but allows user to edit via text.
- */
-export const LambdaEditor = observer(
-  (props: {
-    className?: string | undefined;
-    disabled: boolean;
-    lambdaEditorState: LambdaEditorState;
-    /**
-     * TODO: when we pass in these expected type we should match a type as expected type if it's covariance, i.e. it is a subtype of
-     * the expected type. Note that we also have to handle that relationship for Primitive type
-     * See https://dzone.com/articles/covariance-and-contravariance
-     */
-    expectedType?: Type | undefined;
-    matchedExpectedType?: (() => boolean) | undefined;
-    onExpectedTypeLabelSelect?: (() => void) | undefined;
-    /**
-     * As backdrop element is often shared in the application, and there could be multiple
-     * editor using that backdrop, we could end up in situation where some such editors
-     * have parser errors and some don't (this can happen when user make edits very quickly 2 lambda
-     * editor and causes parsers error simultaneously). In this case, we want to make sure when
-     * parser error is fixed in one editor, the backdrop is not dismissed immediately.
-     *
-     * NOTE: the current approach has a critical flaw, where on the same screen, there could be multiple
-     * sets of lambda editors with different values for `forceBackdrop`. So really, the only way to
-     * accomondate for this is to have `forceBackdrop` as a global value. Or we should get rid of this
-     * backdrop mechanism altogether as it's not really a good UX pattern. i.e. quick evaluation makes
-     * us believe that this is a good option, user will lose what they type, but the most recent parsable
-     * input will still be captured.
-     */
-    forceBackdrop: boolean;
-    /**
-     * To whether or not disable expasipn toggler
-     */
-    disableExpansion?: boolean | undefined;
-    /**
-     * To whether show the inline editor in expanded mode initially and
-     * disable expansion toggler
-     *
-     * This flag will override the effect of `forceExpansion`
-     */
-    forceExpansion?: boolean | undefined;
-    /**
-     * To whether or not disable popup mode
-     */
-    disablePopUp?: boolean | undefined;
-    /**
-     * To whether or not style inline editor
-     */
-    useBaseTextEditorSettings?: boolean | undefined;
-    /**
-     * To whether or not hide parser error bar in inline mode
-     */
-    hideErrorBar?: boolean | undefined;
-    onEditorFocus?: (() => void) | undefined;
-  }) => {
+type LambdaEditorBaseProps = {
+  className?: string | undefined;
+  disabled: boolean;
+  lambdaEditorState: LambdaEditorState;
+  /**
+   * As backdrop element is often shared in the application, and there could be multiple
+   * editor using that backdrop, we could end up in situation where some such editors
+   * have parser errors and some don't (this can happen when user make edits very quickly 2 lambda
+   * editor and causes parsers error simultaneously). In this case, we want to make sure when
+   * parser error is fixed in one editor, the backdrop is not dismissed immediately.
+   *
+   * NOTE: the current approach has a critical flaw, where on the same screen, there could be multiple
+   * sets of lambda editors with different values for `forceBackdrop`. So really, the only way to
+   * accomondate for this is to have `forceBackdrop` as a global value. Or we should get rid of this
+   * backdrop mechanism altogether as it's not a common UX pattern. i.e. quick evaluation makes
+   * us believe that this is a good option, user will lose what they type, but the most recent parsable
+   * input will still be captured.
+   */
+  forceBackdrop: boolean;
+  autoFocus?: boolean | undefined;
+  onEditorFocus?: (() => void) | undefined;
+};
+
+export const InlineLambdaEditor = observer(
+  (
+    props: LambdaEditorBaseProps & {
+      /**
+       * TODO: when we pass in these expected type we should match a type as expected type if it's covariance, i.e. it is a subtype of
+       * the expected type. Note that we also have to handle that relationship for Primitive type
+       * See https://dzone.com/articles/covariance-and-contravariance
+       */
+      expectedType?: Type | undefined;
+      matchedExpectedType?: (() => boolean) | undefined;
+      onExpectedTypeLabelSelect?: (() => void) | undefined;
+      /**
+       * To whether or not disable expasipn toggler
+       */
+      disableExpansion?: boolean | undefined;
+      /**
+       * To whether show the inline editor in expanded mode initially and
+       * disable expansion toggler
+       *
+       * This flag will override the effect of `forceExpansion`
+       */
+      forceExpansion?: boolean | undefined;
+      /**
+       * To whether or not disable popup mode
+       */
+      disablePopUp?: boolean | undefined;
+      /**
+       * To whether or not hide parser error bar in inline mode
+       */
+      hideErrorBar?: boolean | undefined;
+    },
+  ) => {
     const {
       className,
       lambdaEditorState,
@@ -693,8 +702,8 @@ export const LambdaEditor = observer(
       disableExpansion,
       forceExpansion,
       disablePopUp,
-      useBaseTextEditorSettings,
       hideErrorBar,
+      autoFocus,
       onEditorFocus,
     } = props;
     const [showPopUp, setShowPopUp] = useState(false);
@@ -715,7 +724,7 @@ export const LambdaEditor = observer(
       return (
         <>
           <div className="lambda-editor" />
-          <LambdaEditorPopUp
+          <LambdaEditor_PopUp
             className={className}
             disabled={disabled}
             lambdaEditorState={lambdaEditorState}
@@ -726,7 +735,7 @@ export const LambdaEditor = observer(
       );
     }
     return (
-      <LambdaEditorInline
+      <LambdaEditor_Inner
         /**
          * See the usage of `transformStringToLambda` as well as the instatiation of the editor in `LambdaEditorInner`.
          * One of the big problem is that the editor uses lambda editor state (there are some non-trivial logic there, that
@@ -753,6 +762,7 @@ export const LambdaEditor = observer(
          */
         key={lambdaEditorState.uuid}
         className={className}
+        inline={true}
         disabled={disabled}
         lambdaEditorState={lambdaEditorState}
         transformStringToLambda={debouncedTransformStringToLambda}
@@ -761,17 +771,54 @@ export const LambdaEditor = observer(
         onExpectedTypeLabelSelect={onExpectedTypeLabelSelect}
         forceBackdrop={forceBackdrop}
         disableExpansion={disableExpansion}
+        disablePopUp={disablePopUp}
+        autoFocus={autoFocus}
+        openInPopUp={openInPopUp}
+        onEditorFocus={onEditorFocus}
+        hideErrorBar={hideErrorBar}
         forceExpansion={
           disableExpansion !== undefined
             ? !disableExpansion && forceExpansion
             : forceExpansion
         }
-        disablePopUp={disablePopUp}
-        useBaseTextEditorSettings={useBaseTextEditorSettings}
-        hideErrorBar={hideErrorBar}
-        openInPopUp={openInPopUp}
-        onEditorFocus={onEditorFocus}
       />
     );
   },
 );
+
+export const LambdaEditor = observer((props: LambdaEditorBaseProps) => {
+  const {
+    className,
+    lambdaEditorState,
+    disabled,
+    forceBackdrop,
+    autoFocus,
+    onEditorFocus,
+  } = props;
+  const debouncedTransformStringToLambda = useMemo(
+    () =>
+      disabled
+        ? undefined
+        : debounce(
+            () => lambdaEditorState.convertLambdaGrammarStringToObject(),
+            1000,
+          ),
+    [lambdaEditorState, disabled],
+  );
+  return (
+    <LambdaEditor_Inner
+      key={lambdaEditorState.uuid}
+      className={className}
+      disabled={disabled}
+      lambdaEditorState={lambdaEditorState}
+      transformStringToLambda={debouncedTransformStringToLambda}
+      forceBackdrop={forceBackdrop}
+      autoFocus={autoFocus}
+      onEditorFocus={onEditorFocus}
+      disableExpansion={true}
+      forceExpansion={true}
+      disablePopUp={true}
+      hideErrorBar={true}
+    />
+  );
+});

package/src/graph-manager/protocol/pure/v1/V1_QueryBuilder_PureGraphManagerExtension.ts

@@ -17,7 +17,7 @@
 import {
   EngineRuntime,
   GraphBuilderError,
-  MappingInclude,
+  MappingIncludeMapping,
   V1_GraphBuilderContextBuilder,
   V1_Mapping,
   V1_MAPPING_ELEMENT_PROTOCOL_TYPE,
@@ -33,6 +33,7 @@ import {
   type V1_EngineRuntime,
   CORE_PURE_PATH,
   getAllIncludedMappings,
+  V1_MappingIncludeMapping,
 } from '@finos/legend-graph';
 import type { EntitiesWithOrigin, Entity } from '@finos/legend-storage';
 import {
@@ -41,6 +42,7 @@ import {
   guaranteeNonEmptyString,
   guaranteeType,
   type PlainObject,
+  isNonNullable,
 } from '@finos/legend-shared';
 import { MappingRuntimeCompatibilityAnalysisResult } from '../../../action/analytics/MappingRuntimeCompatibilityAnalysis.js';
 import { ServiceExecutionAnalysisResult } from '../../../action/analytics/ServiceExecutionAnalysis.js';
@@ -93,18 +95,23 @@ export class V1_QueryBuilder_PureGraphManagerExtension extends QueryBuilder_Pure
       v1Mappings.forEach((element) => {
         const mapping = mappings.find((e) => e.path === element.path);
         if (mapping) {
-          mapping.includes = element.includedMappings.map(
-            (mappingInclude) =>
-              new MappingInclude(
-                mapping,
-                context.resolveMapping(
-                  guaranteeNonEmptyString(
-                    mappingInclude.includedMapping,
-                    `Mapping include path is missing or empty`,
+          mapping.includes = element.includedMappings
+            .map((mappingInclude) => {
+              // TODO : handle for mapping include dataspace
+              if (mappingInclude instanceof V1_MappingIncludeMapping) {
+                return new MappingIncludeMapping(
+                  mapping,
+                  context.resolveMapping(
+                    guaranteeNonEmptyString(
+                      mappingInclude.includedMapping,
+                      `Mapping include path is missing or empty`,
+                    ),
                   ),
-                ),
-              ),
-          );
+                );
+              }
+              return undefined;
+            })
+            .filter(isNonNullable);
         }
       });
       // handle runtimes
@@ -194,18 +201,23 @@ export class V1_QueryBuilder_PureGraphManagerExtension extends QueryBuilder_Pure
       .forEach((element) => {
         const mapping = graph.getNullableMapping(element.path);
         if (mapping) {
-          mapping.includes = element.includedMappings.map(
-            (include) =>
-              new MappingInclude(
-                mapping,
-                context.resolveMapping(
-                  guaranteeNonEmptyString(
-                    include.includedMapping,
-                    `Mapping include path is missing or empty`,
+          mapping.includes = element.includedMappings
+            .map((mappingInclude) => {
+              // TODO : handle for mapping include dataspace
+              if (mappingInclude instanceof V1_MappingIncludeMapping) {
+                return new MappingIncludeMapping(
+                  mapping,
+                  context.resolveMapping(
+                    guaranteeNonEmptyString(
+                      mappingInclude.includedMapping,
+                      `Mapping include path is missing or empty`,
+                    ),
                   ),
-                ),
-              ),
-          );
+                );
+              }
+              return undefined;
+            })
+            .filter(isNonNullable);
         }
       });