@finos/legend-query-builder 4.19.22 → 4.19.24

package/src/components/filter/QueryBuilderFilterPanel.tsx

@@ -101,7 +101,6 @@ import {
   useApplicationStore,
 } from '@finos/legend-application';
 import {
-  type Type,
   type ValueSpecification,
   AbstractPropertyExpression,
   extractElementNameFromPath,
@@ -881,16 +880,30 @@ export const QueryBuilderFilterRelationColumnBadge = observer(
 );
 
 const canDropTypeOntoNodeValue = (
-  type: Type | undefined,
+  item: QueryBuilderFilterValueDropTarget,
+  type: string,
   condition: FilterConditionState,
 ): boolean => {
   const conditionOperator = condition.operator;
   const conditionValueType = condition.leftConditionType;
-  return (
-    !(conditionOperator instanceof QueryBuilderFilterOperator_In) &&
-    !(conditionOperator instanceof QueryBuilderFilterOperator_NotIn) &&
-    isTypeCompatibleForAssignment(type, conditionValueType)
-  );
+  const itemType = getDNDItemType(item, type);
+  if (
+    conditionOperator instanceof QueryBuilderFilterOperator_In ||
+    conditionOperator instanceof QueryBuilderFilterOperator_NotIn
+  ) {
+    // `in` / `not in` filter conditions take a collection value, so only a
+    // collection-multiplicity (`[*]`) parameter can be dropped onto them;
+    // scalar properties/columns can never satisfy a collection operator
+    if (type !== QUERY_BUILDER_VARIABLE_DND_TYPE) {
+      return false;
+    }
+    const variable = (item as QueryBuilderVariableDragSource).variable;
+    return (
+      variable.multiplicity.upperBound !== 1 &&
+      isTypeCompatibleForAssignment(itemType, conditionValueType)
+    );
+  }
+  return isTypeCompatibleForAssignment(itemType, conditionValueType);
 };
 
 const QueryBuilderFilterConditionEditor = observer(
@@ -912,7 +925,7 @@ const QueryBuilderFilterConditionEditor = observer(
         const itemType = getDNDItemType(item, type);
         if (
           itemType !== undefined &&
-          canDropTypeOntoNodeValue(itemType, node.condition)
+          canDropTypeOntoNodeValue(item, type, node.condition)
         ) {
           try {
             if (
@@ -1047,7 +1060,8 @@ const QueryBuilderFilterConditionEditor = observer(
         accept: CAN_DROP_FILTER_VALUE_DND_TYPES,
         canDrop: (item, monitor): boolean =>
           canDropTypeOntoNodeValue(
-            getDNDItemType(item, monitor.getItemType() as string),
+            item,
+            monitor.getItemType() as string,
             node.condition,
           ),
         drop: (item, monitor): void => {
@@ -1072,7 +1086,8 @@ const QueryBuilderFilterConditionEditor = observer(
           monitor.getItemType()?.toString() ?? '',
         ) &&
         canDropTypeOntoNodeValue(
-          getDNDItemType(monitor.getItem(), monitor.getItemType() as string),
+          monitor.getItem(),
+          monitor.getItemType() as string,
           node.condition,
         ),
     }));

package/src/components/shared/LambdaEditor.tsx

@@ -42,8 +42,8 @@ import {
   clearMarkers,
   setErrorMarkers,
   CODE_EDITOR_LANGUAGE,
-  CODE_EDITOR_THEME,
   PURE_CODE_EDITOR_WORD_SEPARATORS,
+  getCodeEditorThemeForAppTheme,
   type CompletionItem,
 } from '@finos/legend-code-editor';
 import { disposeCodeEditor } from '@finos/legend-lego/code-editor';
@@ -273,10 +273,9 @@ const LambdaEditor_Inner = observer(
         const _editor = monacoEditorAPI.create(element, {
           ...getBaseCodeEditorOptions(),
           language: CODE_EDITOR_LANGUAGE.PURE,
-          theme: applicationStore.layoutService
-            .TEMPORARY__isLightColorThemeEnabled
-            ? CODE_EDITOR_THEME.BUILT_IN__VSCODE_LIGHT
-            : CODE_EDITOR_THEME.DEFAULT_DARK,
+          theme: getCodeEditorThemeForAppTheme(
+            applicationStore.layoutService.TEMPORARY__isLightColorThemeEnabled,
+          ),
           ...lambdaEditorOptions,
         });
         setEditor(_editor);
@@ -311,10 +310,9 @@ const LambdaEditor_Inner = observer(
     useEffect(() => {
       if (editor) {
         editor.updateOptions({
-          theme: applicationStore.layoutService
-            .TEMPORARY__isLightColorThemeEnabled
-            ? CODE_EDITOR_THEME.BUILT_IN__VSCODE_LIGHT
-            : CODE_EDITOR_THEME.DEFAULT_DARK,
+          theme: getCodeEditorThemeForAppTheme(
+            applicationStore.layoutService.TEMPORARY__isLightColorThemeEnabled,
+          ),
         });
       }
     }, [
@@ -608,10 +606,9 @@ const LambdaEditor_PopUp = observer(
         const _editor = monacoEditorAPI.create(element, {
           ...getBaseCodeEditorOptions(),
           language: CODE_EDITOR_LANGUAGE.PURE,
-          theme: applicationStore.layoutService
-            .TEMPORARY__isLightColorThemeEnabled
-            ? CODE_EDITOR_THEME.BUILT_IN__VSCODE_LIGHT
-            : CODE_EDITOR_THEME.DEFAULT_DARK,
+          theme: getCodeEditorThemeForAppTheme(
+            applicationStore.layoutService.TEMPORARY__isLightColorThemeEnabled,
+          ),
         });
         setEditor(_editor);
       }

package/src/components/sql-playground/SQLPlaygroundEditor.tsx

@@ -20,8 +20,8 @@ import { useCallback, useEffect, useRef, useState } from 'react';
 import { useCommands } from '@finos/legend-application';
 import {
   CODE_EDITOR_LANGUAGE,
-  CODE_EDITOR_THEME,
   getBaseCodeEditorOptions,
+  getCodeEditorThemeForAppTheme,
 } from '@finos/legend-code-editor';
 import {
   editor as monacoEditorAPI,
@@ -79,10 +79,11 @@ export const PlaygroundSQLCodeEditor = observer(
         playgroundState.setTheme(enableDarkMode ? 'dark' : 'light');
         const newEditor = monacoEditorAPI.create(element, {
           ...getBaseCodeEditorOptions(),
-          theme:
-            playgroundState.theme === 'light'
-              ? CODE_EDITOR_THEME.GITHUB_LIGHT
-              : CODE_EDITOR_THEME.DEFAULT_DARK,
+          // NOTE: Monaco themes are global, so this theme applies to every
+          // editor on the page and must match the application's theme
+          theme: getCodeEditorThemeForAppTheme(
+            playgroundState.theme === 'light',
+          ),
           language: CODE_EDITOR_LANGUAGE.SQL,
           padding: {
             top: 10,

package/src/index.ts

@@ -53,6 +53,7 @@ export {
   getTDSColumnDerivedProperyFromType,
   buildTDSSortTypeExpression,
 } from './stores/fetch-structure/tds/QueryBuilderTDSHelper.js';
+export { QueryBuilderTDSState } from './stores/fetch-structure/tds/QueryBuilderTDSState.js';
 export { type ExportDataInfo } from './stores/QueryBuilderResultState.js';
 export { QueryBuilderPropertySearchState } from './stores/explorer/QueryBuilderPropertySearchState.js';
 export {

package/src/stores/QueryBuilderValueSpecificationHelper.ts

@@ -264,7 +264,8 @@ export const isTypeCompatibleForAssignment = (
     // This is because we would simulate auto-boxing for date by altering the
     // Pure function used for the operation
     // e.g. LHS(DateTime) = RHS(Date) -> we use isOnDay() instead of is()
-    DATE_PRIMITIVE_TYPES.includes(normalizedTypePath) ||
+    (DATE_PRIMITIVE_TYPES.includes(normalizedTypePath) &&
+      DATE_PRIMITIVE_TYPES.includes(normalizedAssignmentTypePath)) ||
     normalizedTypePath === normalizedAssignmentTypePath ||
     isSuperType(assignmentType, type)
   );

package/src/stores/filter/operators/QueryBuilderFilterOperator_In.ts

@@ -41,6 +41,7 @@ import {
   buildNotExpression,
   getCollectionValueSpecificationType,
   getStandardPrimitiveTypeEquivalent,
+  isTypeCompatibleForAssignment,
   unwrapNotExpression,
 } from '../../QueryBuilderValueSpecificationHelper.js';
 import { type Hashable, hashArray } from '@finos/legend-shared';
@@ -141,7 +142,12 @@ export class QueryBuilderFilterOperator_In
         if (valueSpec.multiplicity.upperBound === 1) {
           return false;
         }
-        return propertyType === valueSpec.genericType?.value.rawType;
+        const variableType = valueSpec.genericType?.value.rawType;
+        // NOTE: use the same loose, numeric/date-family aware check as value assignment,
+        // so e.g. an `Integer[*]` parameter is still recognized as compatible with
+        // an `Integer` property even when the two don't resolve to the exact same
+        // `Type` instance (this can happen when the parameter is parsed from PURE text)
+        return isTypeCompatibleForAssignment(variableType, propertyType);
       }
     }
     return false;

package/src/stores/query-workflow/QueryBuilderWorkFlowState.ts

@@ -34,6 +34,25 @@ export abstract class QueryBuilderWorkflowState {
     state: QueryBuilderState,
   ): FetchStructureLayoutConfig;
 
+  /**
+   * Whether the header shows its Advanced and Help menus; a workflow that
+   * embeds the query builder for a part of a query, e.g. a Legend Cube data
+   * space source, hides them
+   */
+  get showHeaderMenus(): boolean {
+    return true;
+  }
+
+  /** Whether a projection column can be given an aggregate operator */
+  get showProjectionAggregation(): boolean {
+    return true;
+  }
+
+  /** Whether the projection shows its query options: sort, distinct, limit and dates */
+  get showQueryOptions(): boolean {
+    return true;
+  }
+
   updateActionConfig(actionConfig: QueryBuilderActionConfig): void {
     this.actionConfig = actionConfig;
   }