@finos/legend-data-cube 0.3.117 → 0.3.119

package/src/components/view/filter/DataCubeFilterEditor.tsx

@@ -18,9 +18,6 @@ import {
   BasePopover,
   cn,
   DataCubeIcon,
-  DateCalendar,
-  DatePicker,
-  DatePickerField,
   useDropdownMenu,
   useForkRef,
 } from '@finos/legend-art';
@@ -29,8 +26,18 @@ import {
   DataCubeOperationAdvancedValueType,
   DataCubeQueryFilterGroupOperator,
   getDataType,
+  isCurrentMomentValue,
+  isDateTimeType,
   type DataCubeOperationValue,
 } from '../../../stores/core/DataCubeQueryEngine.js';
+import {
+  buildDateValue,
+  DATE_VALUE_MODE_DESCRIPTION,
+  DATE_VALUE_MODE_LABEL,
+  getDateValueFormats,
+  getDateValueMode,
+  getDateValueModes,
+} from './DataCubeFilterEditorUtils.js';
 import {
   DataCubeFilterEditorConditionGroupTreeNode,
   DataCubeFilterEditorConditionTreeNode,
@@ -52,11 +59,7 @@ import {
   useState,
   useMemo,
 } from 'react';
-import {
-  DATE_FORMAT,
-  PRECISE_PRIMITIVE_TYPE,
-  PRIMITIVE_TYPE,
-} from '@finos/legend-graph';
+import { PRECISE_PRIMITIVE_TYPE, PRIMITIVE_TYPE } from '@finos/legend-graph';
 
 import {
   formatDate,
@@ -228,93 +231,131 @@ const DataCubeEditorFilterConditionNodeNumberValueEditor = observer(
   }),
 );
 
-// NOTE: this has to be declared here instead of defined inline in slot configuration of DatePicker
-// else, with each re-render, a new function will be created and the ref might be lost
-const CustomDateFieldPicker = forwardRef<HTMLInputElement>(
-  function CustomDateFieldPicker(p, r) {
-    return (
-      <DatePickerField
-        {...p}
-        ref={r}
-        className="h-5 w-full flex-shrink-0 border border-neutral-400 px-1 pr-5 text-sm disabled:border-neutral-300 disabled:bg-neutral-50 disabled:text-neutral-300"
-      />
-    );
-  },
-);
+const DATE_INPUT_CLASSNAME =
+  'h-5 w-full flex-shrink-0 border border-neutral-400 px-1 text-sm disabled:border-neutral-300 disabled:bg-neutral-50 disabled:text-neutral-300';
 
-const CustomDateFieldPickerOpenCalendarButton = observer(
-  (props: { value: string; updateValue: (value: string) => void }) => {
-    const { value, updateValue } = props;
-    const [anchorEl, setAnchorEl] = useState<null | HTMLElement>(null);
+/**
+ * Editor for an absolute date value, picked with the control of the browser,
+ * like the query builder does. A value which carries a time of day is edited
+ * down to the second, and is written back with the time zone of the browser.
+ */
+const DataCubeEditorFilterConditionNodeDatePicker = observer(
+  forwardRef<
+    HTMLInputElement,
+    {
+      value: string;
+      updateValue: (value: string) => void;
+      valueType: string;
+    }
+  >(function DataCubeEditorFilterConditionNodeDatePicker(props, ref) {
+    const { value, updateValue, valueType } = props;
+    const hasTime = isDateTimeType(valueType);
+    const { valueFormat, displayFormat } = getDateValueFormats(valueType);
+    const moment = parseISO(value);
 
     return (
-      <>
-        <button
-          className="absolute right-0 top-0 flex h-5 w-5 items-center justify-center"
-          title="Open Date Picker..."
-          onClick={(event) => {
-            setAnchorEl(event.currentTarget);
-          }}
-          tabIndex={-1}
-        >
-          <DataCubeIcon.Calendar className="text-lg text-neutral-500 hover:text-neutral-600" />
-        </button>
-        <BasePopover
-          open={Boolean(anchorEl)}
-          anchorEl={anchorEl}
-          anchorOrigin={{ vertical: 'bottom', horizontal: 'center' }}
-          transformOrigin={{ vertical: 'top', horizontal: 'center' }}
-          onClose={() => setAnchorEl(null)}
-          classes={{
-            root: 'data-cube-editor-date-calendar mt-0.5',
-            paper: 'shadow-md rounded-none border border-neutral-300',
-          }}
-        >
-          <DateCalendar
-            autoFocus={true}
-            value={parseISO(value)}
-            onChange={(newValue: Date) => {
-              updateValue(formatDate(newValue, DATE_FORMAT));
-              setAnchorEl(null);
-            }}
-          />
-        </BasePopover>
-      </>
+      <input
+        ref={ref}
+        className={DATE_INPUT_CLASSNAME}
+        // NOTE: despite its name, `datetime-local` registers a moment in the
+        // time zone of the browser
+        // See https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/datetime-local#setting_timezones
+        type={hasTime ? 'datetime-local' : 'date'}
+        // NOTE: configure the step so the seconds can be picked
+        // See https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/datetime-local#step
+        step={hasTime ? '1' : undefined}
+        spellCheck={false}
+        value={
+          !Number.isNaN(moment.getTime())
+            ? formatDate(moment, displayFormat)
+            : ''
+        }
+        onChange={(event) => {
+          const newMoment = parseISO(event.target.value);
+          // NOTE: the control reports an empty value while the user is still
+          // filling it in
+          if (!Number.isNaN(newMoment.getTime())) {
+            updateValue(formatDate(newMoment, valueFormat));
+          }
+        }}
+      />
     );
-  },
+  }),
 );
 
+/**
+ * Date value editor for scalar filter conditions. For columns which carry a
+ * date, it lets the user pick how the value is specified: an absolute date, an
+ * absolute date and time, `today()` or `now()`.
+ */
 const DataCubeEditorFilterConditionNodeDateValueEditor = observer(
   forwardRef<
     HTMLInputElement,
     {
-      value: string;
-      updateValue: (value: string) => void;
+      node: DataCubeFilterEditorConditionTreeNode;
     }
-  >(function DataCubeEditorFilterConditionNodeValueEditor(props, ref) {
-    const { value, updateValue } = props;
+  >(function DataCubeEditorFilterConditionNodeDateValueEditor(props, ref) {
+    const { node } = props;
+    const value = node.value;
+    const modes = getDateValueModes(node.column.type);
+    const mode = getDateValueMode(value);
+    const [
+      openModeDropdown,
+      closeModeDropdown,
+      modeDropdownProps,
+      modeDropdownPropsOpen,
+    ] = useDropdownMenu();
 
-    return (
-      <DatePicker
+    const datePicker = (
+      <DataCubeEditorFilterConditionNodeDatePicker
         ref={ref}
-        value={parseISO(value)}
-        format={DATE_FORMAT}
-        slots={{
-          field: CustomDateFieldPicker,
-          openPickerButton: () => (
-            <CustomDateFieldPickerOpenCalendarButton
-              value={value}
-              updateValue={updateValue}
-            />
-          ),
-        }}
-        onChange={(newValue: Date | null) => {
-          if (newValue) {
-            updateValue(formatDate(newValue, DATE_FORMAT));
-          }
-        }}
+        value={value.value as string}
+        updateValue={(val) => node.updateValue(val)}
+        valueType={value.type}
       />
     );
+
+    // For columns which carry no date (e.g. a time-of-day column), only the
+    // date picker is shown, none of the modes apply.
+    if (!modes.length) {
+      return datePicker;
+    }
+
+    return (
+      <div className="flex h-full w-full items-center">
+        <FormDropdownMenuTrigger
+          className="relative mr-1 w-24 flex-shrink-0"
+          onClick={openModeDropdown}
+          open={modeDropdownPropsOpen}
+          title={DATE_VALUE_MODE_DESCRIPTION[mode]}
+        >
+          {DATE_VALUE_MODE_LABEL[mode]}
+        </FormDropdownMenuTrigger>
+        <FormDropdownMenu className="w-24" {...modeDropdownProps}>
+          {modes.map((_mode) => (
+            <FormDropdownMenuItem
+              key={_mode}
+              onClick={() => {
+                if (_mode !== mode) {
+                  node.setValue(buildDateValue(_mode, value));
+                }
+                closeModeDropdown();
+              }}
+              autoFocus={_mode === mode}
+              title={DATE_VALUE_MODE_DESCRIPTION[_mode]}
+            >
+              {DATE_VALUE_MODE_LABEL[_mode]}
+            </FormDropdownMenuItem>
+          ))}
+        </FormDropdownMenu>
+        {/* NOTE: the date control sizes itself against its container, so it
+        needs one which is only as wide as what the mode selector leaves, else
+        it overflows the value editor. */}
+        {!isCurrentMomentValue(value) && (
+          <div className="min-w-0 flex-1">{datePicker}</div>
+        )}
+      </div>
+    );
   }),
 );
 
@@ -454,12 +495,13 @@ const DataCubeEditorFilterConditionNodeListValueEditor = observer(
         case PRECISE_PRIMITIVE_TYPE.STRICTTIME:
         case PRECISE_PRIMITIVE_TYPE.TIMESTAMP: {
           // try parse ISO, else use formatted now
+          const { valueFormat } = getDateValueFormats(firstType);
           let dateVal = trimmed;
           try {
             const d = parseISO(trimmed);
-            dateVal = formatDate(d, DATE_FORMAT);
+            dateVal = formatDate(d, valueFormat);
           } catch {
-            dateVal = formatDate(new Date(), DATE_FORMAT);
+            dateVal = formatDate(new Date(), valueFormat);
           }
           newItem = { type: firstType, value: dateVal };
           break;
@@ -621,10 +663,14 @@ const DataCubeEditorFilterConditionNodeListValueEditor = observer(
                           case PRECISE_PRIMITIVE_TYPE.STRICTTIME:
                           case PRECISE_PRIMITIVE_TYPE.TIMESTAMP:
                             return (
-                              <DataCubeEditorFilterConditionNodeDateValueEditor
+                              <DataCubeEditorFilterConditionNodeDatePicker
+                                valueType={it.type}
                                 value={String(
                                   it.value ??
-                                    formatDate(new Date(), DATE_FORMAT),
+                                    formatDate(
+                                      new Date(),
+                                      getDateValueFormats(it.type).valueFormat,
+                                    ),
                                 )}
                                 updateValue={(v: string) => {
                                   const next = localItems.slice();
@@ -719,12 +765,13 @@ const DataCubeEditorFilterConditionNodeValueEditor = observer(
   forwardRef<
     HTMLElement,
     {
+      node: DataCubeFilterEditorConditionTreeNode;
       value: DataCubeOperationValue;
       updateValue: (value: unknown) => void;
       view: DataCubeViewState;
     }
   >(function DataCubeEditorFilterConditionNodeValueEditor(props, ref) {
-    const { value, updateValue, view } = props;
+    const { node, value, updateValue, view } = props;
     // WIP: support column
     switch (value.type) {
       case PRIMITIVE_TYPE.STRING:
@@ -774,11 +821,12 @@ const DataCubeEditorFilterConditionNodeValueEditor = observer(
       case PRECISE_PRIMITIVE_TYPE.DATETIME:
       case PRECISE_PRIMITIVE_TYPE.STRICTTIME:
       case PRECISE_PRIMITIVE_TYPE.TIMESTAMP:
+      case DataCubeOperationAdvancedValueType.TODAY:
+      case DataCubeOperationAdvancedValueType.NOW:
         return (
           <DataCubeEditorFilterConditionNodeDateValueEditor
             ref={ref as React.RefObject<HTMLInputElement>}
-            value={value.value as string}
-            updateValue={(val) => updateValue(val)}
+            node={node}
           />
         );
       case DataCubeOperationAdvancedValueType.COLUMN:
@@ -909,6 +957,12 @@ const DataCubeEditorFilterConditionNodeDisplay = observer(
       () => valueEditorRef.current?.focus(),
       [],
     );
+    // NOTE: the value editor for columns which carry a date is wider to
+    // accommodate the selector for switching between a specific date and the
+    // `today()`/`now()` function.
+    const hasDateValueModeSelector = Boolean(
+      getDateValueModes(node.column.type).length,
+    );
 
     return (
       <div className="group flex h-6 items-center">
@@ -1034,9 +1088,17 @@ const DataCubeEditorFilterConditionNodeDisplay = observer(
               </FormDropdownMenuItem>
             ))}
         </FormDropdownMenu>
-        <div className="relative w-32 flex-shrink-0">
+        <div
+          className={cn('relative flex-shrink-0', {
+            // NOTE: wide enough for a date-time value, which the user can
+            // switch to whenever the mode selector is shown
+            'w-80': hasDateValueModeSelector,
+            'w-32': !hasDateValueModeSelector,
+          })}
+        >
           <DataCubeEditorFilterConditionNodeValueEditor
             ref={valueEditorRef}
+            node={node}
             value={node.value}
             updateValue={(val) => node.updateValue(val)}
             view={view}

package/src/components/view/filter/DataCubeFilterEditorUtils.ts

@@ -0,0 +1,165 @@
+/**
+ * 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 {
+  DATE_FORMAT,
+  DATE_TIME_FORMAT,
+  PRIMITIVE_TYPE,
+} from '@finos/legend-graph';
+import { formatDate, parseISO } from '@finos/legend-shared';
+import {
+  DataCubeOperationAdvancedValueType,
+  getCurrentMomentValueType,
+  isDateTimeType,
+  type DataCubeOperationValue,
+} from '../../../stores/core/DataCubeQueryEngine.js';
+
+/**
+ * The ways a date filter value can be specified: as an absolute moment - a
+ * date, or a date and a time of day - or as a function resolved when the query
+ * runs.
+ */
+export enum DataCubeDateValueMode {
+  ABSOLUTE_DATE = 'ABSOLUTE_DATE',
+  ABSOLUTE_DATE_TIME = 'ABSOLUTE_DATE_TIME',
+  TODAY = 'TODAY',
+  NOW = 'NOW',
+}
+
+export const DATE_VALUE_MODE_LABEL: Record<DataCubeDateValueMode, string> = {
+  [DataCubeDateValueMode.ABSOLUTE_DATE]: 'Date',
+  [DataCubeDateValueMode.ABSOLUTE_DATE_TIME]: 'Date Time',
+  [DataCubeDateValueMode.TODAY]: 'Today',
+  [DataCubeDateValueMode.NOW]: 'Now',
+};
+
+// NOTE: the wording mirrors the date picker of the query builder, where a
+// value specified by the user is an "absolute" one, as opposed to one which
+// resolves relative to the moment the query runs.
+export const DATE_VALUE_MODE_DESCRIPTION: Record<
+  DataCubeDateValueMode,
+  string
+> = {
+  [DataCubeDateValueMode.ABSOLUTE_DATE]: 'Absolute date',
+  [DataCubeDateValueMode.ABSOLUTE_DATE_TIME]: 'Absolute date and time',
+  [DataCubeDateValueMode.NOW]: 'now()',
+  [DataCubeDateValueMode.TODAY]: 'today()',
+};
+
+// The format a `datetime-local` input takes: down to the second, and without
+// the time zone, which is not part of what the user picks - it is taken from
+// the browser when the value is written back out.
+const DATE_TIME_INPUT_FORMAT = "yyyy-MM-dd'T'HH:mm:ss";
+
+/**
+ * Returns the format the specified date value is stored in, and the format the
+ * editor displays it in. These differ for a date-time, whose value - see
+ * `_defaultPrimitiveTypeValue()` - carries the time zone, which is more than
+ * the editor shows.
+ */
+export function getDateValueFormats(valueType: string): {
+  valueFormat: string;
+  displayFormat: string;
+} {
+  return isDateTimeType(valueType)
+    ? { valueFormat: DATE_TIME_FORMAT, displayFormat: DATE_TIME_INPUT_FORMAT }
+    : { valueFormat: DATE_FORMAT, displayFormat: DATE_FORMAT };
+}
+
+export function getDateValueMode(
+  value: DataCubeOperationValue,
+): DataCubeDateValueMode {
+  switch (value.type) {
+    case DataCubeOperationAdvancedValueType.TODAY:
+      return DataCubeDateValueMode.TODAY;
+    case DataCubeOperationAdvancedValueType.NOW:
+      return DataCubeDateValueMode.NOW;
+    default:
+      return isDateTimeType(value.type)
+        ? DataCubeDateValueMode.ABSOLUTE_DATE_TIME
+        : DataCubeDateValueMode.ABSOLUTE_DATE;
+  }
+}
+
+/**
+ * Returns the ways a condition on the specified column can specify its value;
+ * empty when the column carries no date (e.g. a time-of-day column), where
+ * none of these apply.
+ *
+ * NOTE: every column which carries a date offers all of them, like the query
+ * builder does: `Date` is the super type of both `StrictDate` and `DateTime`,
+ * so a column typed with it can hold a time of day, and comparing a date
+ * against a moment which carries one is meaningful either way around.
+ */
+export function getDateValueModes(columnType: string): DataCubeDateValueMode[] {
+  return getCurrentMomentValueType(columnType)
+    ? [
+        DataCubeDateValueMode.ABSOLUTE_DATE,
+        DataCubeDateValueMode.ABSOLUTE_DATE_TIME,
+        DataCubeDateValueMode.TODAY,
+        DataCubeDateValueMode.NOW,
+      ]
+    : [];
+}
+
+/**
+ * Returns the moment a date value specifies, defaulting to the current one
+ * where it specifies none, e.g. when it is `today()`.
+ */
+function _dateValueMoment(value: DataCubeOperationValue): Date {
+  if (typeof value.value === 'string') {
+    const moment = parseISO(value.value);
+    if (!Number.isNaN(moment.getTime())) {
+      return moment;
+    }
+  }
+  return new Date();
+}
+
+/**
+ * Returns the value a condition takes when switched to the specified mode,
+ * keeping the moment it currently specifies.
+ *
+ * NOTE: an absolute value is built with the primitive type matching what it
+ * specifies rather than with the type of the column. The type of a value names
+ * the literal it is written as, which the type of the column does not: `Date`
+ * says nothing about whether a time of day is meant, and a timestamp column is
+ * typed with a relational data type, which no literal can be spelled with.
+ * This is also the type the value comes back as when the query it is written
+ * to is read again, so a value keeps its shape across a round-trip.
+ */
+export function buildDateValue(
+  mode: DataCubeDateValueMode,
+  value: DataCubeOperationValue,
+): DataCubeOperationValue {
+  switch (mode) {
+    case DataCubeDateValueMode.TODAY:
+      return { type: DataCubeOperationAdvancedValueType.TODAY };
+    case DataCubeDateValueMode.NOW:
+      return { type: DataCubeOperationAdvancedValueType.NOW };
+    case DataCubeDateValueMode.ABSOLUTE_DATE_TIME:
+      return {
+        type: PRIMITIVE_TYPE.DATETIME,
+        value: formatDate(_dateValueMoment(value), DATE_TIME_FORMAT),
+      };
+    case DataCubeDateValueMode.ABSOLUTE_DATE:
+    default:
+      return {
+        type: PRIMITIVE_TYPE.STRICTDATE,
+        value: formatDate(_dateValueMoment(value), DATE_FORMAT),
+      };
+  }
+}

package/src/stores/core/DataCubeQueryBuilderUtils.ts

@@ -259,8 +259,11 @@ export function _primitiveValue(
     case PRECISE_PRIMITIVE_TYPE.STRICTDATE:
       return _val(new V1_CStrictDate(), guaranteeIsString(value));
     case PRIMITIVE_TYPE.DATETIME:
+    case PRECISE_PRIMITIVE_TYPE.DATETIME:
+    case PRECISE_PRIMITIVE_TYPE.TIMESTAMP:
       return _val(new V1_CDateTime(), guaranteeIsString(value));
     case PRIMITIVE_TYPE.STRICTTIME:
+    case PRECISE_PRIMITIVE_TYPE.STRICTTIME:
       return _val(new V1_CStrictTime(), guaranteeIsString(value));
     case PRIMITIVE_TYPE.LATESTDATE:
       return new V1_CLatestDate();
@@ -372,6 +375,10 @@ export function _value(value: DataCubeOperationValue): V1_ValueSpecification {
       }
       return _primitiveValue(value.type, value.value);
     }
+    case DataCubeOperationAdvancedValueType.TODAY:
+      return _function(_functionName(DataCubeFunction.TODAY), []);
+    case DataCubeOperationAdvancedValueType.NOW:
+      return _function(_functionName(DataCubeFunction.NOW), []);
     case DataCubeOperationAdvancedValueType.COLUMN:
       return _property(guaranteeIsString(value.value));
     case DataCubeOperationAdvancedValueType.LIST: {

package/src/stores/core/DataCubeQueryEngine.ts

@@ -47,6 +47,10 @@ export enum DataCubeFunction {
   FROM = 'meta::pure::mapping::from',
   TO_ONE = 'meta::pure::functions::multiplicity::toOne',
 
+  // date
+  TODAY = 'meta::pure::functions::date::today',
+  NOW = 'meta::pure::functions::date::now',
+
   // sort
   ASCENDING = 'meta::pure::functions::relation::ascending',
   DESCENDING = 'meta::pure::functions::relation::descending',
@@ -157,6 +161,8 @@ export enum DataCubeOperationAdvancedValueType {
   COLUMN = 'COLUMN',
   LIST = 'LIST',
   VOID = 'VOID',
+  TODAY = 'TODAY',
+  NOW = 'NOW',
   // PARAMETER
 }
 
@@ -492,6 +498,65 @@ export function isPrimitiveType(type: string) {
     ] as string[]
   ).includes(type);
 }
+/**
+ * Current-moment values are filter values which resolve at execution time
+ * rather than being specified by the user: `today()` and `now()`.
+ */
+export type DataCubeCurrentMomentValueType =
+  | DataCubeOperationAdvancedValueType.TODAY
+  | DataCubeOperationAdvancedValueType.NOW;
+
+export function isCurrentMomentValue(
+  value: DataCubeOperationValue,
+): value is DataCubeOperationValue & { type: DataCubeCurrentMomentValueType } {
+  return (
+    value.type === DataCubeOperationAdvancedValueType.TODAY ||
+    value.type === DataCubeOperationAdvancedValueType.NOW
+  );
+}
+
+export function isDateType(type: string) {
+  return (
+    [
+      PRIMITIVE_TYPE.DATE,
+      PRIMITIVE_TYPE.STRICTDATE,
+      PRECISE_PRIMITIVE_TYPE.STRICTDATE,
+    ] as string[]
+  ).includes(type);
+}
+
+/**
+ * Unlike `isDateType()`, these types carry a time of day as well as a date,
+ * so their values must be specified (and displayed) down to the second.
+ */
+export function isDateTimeType(type: string) {
+  return (
+    [
+      PRIMITIVE_TYPE.DATETIME,
+      PRECISE_PRIMITIVE_TYPE.DATETIME,
+      PRECISE_PRIMITIVE_TYPE.TIMESTAMP,
+    ] as string[]
+  ).includes(type);
+}
+
+/**
+ * Returns the current-moment value type applicable to a column: `today()`
+ * (StrictDate) for date columns, `now()` (DateTime) for date-time columns.
+ * Returns `undefined` for columns which carry no date (e.g. a time-of-day
+ * column), since a current-moment date value is meaningless there.
+ */
+export function getCurrentMomentValueType(
+  columnType: string,
+): DataCubeCurrentMomentValueType | undefined {
+  if (isDateType(columnType)) {
+    return DataCubeOperationAdvancedValueType.TODAY;
+  }
+  if (isDateTimeType(columnType)) {
+    return DataCubeOperationAdvancedValueType.NOW;
+  }
+  return undefined;
+}
+
 export function isPivotResultColumnName(columnName: string) {
   return columnName.includes(PIVOT_COLUMN_NAME_VALUE_SEPARATOR);
 }

package/src/stores/core/DataCubeSnapshotBuilderUtils.ts

@@ -250,6 +250,20 @@ export function _operationValue(
         _operationValue(val, columnGetter, columnChecker),
       ),
     };
+  } else if (
+    value instanceof V1_AppliedFunction &&
+    matchFunctionName(value.function, DataCubeFunction.TODAY)
+  ) {
+    return {
+      type: DataCubeOperationAdvancedValueType.TODAY,
+    };
+  } else if (
+    value instanceof V1_AppliedFunction &&
+    matchFunctionName(value.function, DataCubeFunction.NOW)
+  ) {
+    return {
+      type: DataCubeOperationAdvancedValueType.NOW,
+    };
   } else if (value === undefined) {
     return {
       type: DataCubeOperationAdvancedValueType.VOID,

package/src/stores/core/filter/DataCubeQueryFilterOperation.ts

@@ -14,7 +14,11 @@
  * limitations under the License.
  */
 
-import type { DataCubeOperationValue } from '../DataCubeQueryEngine.js';
+import {
+  getCurrentMomentValueType,
+  isCurrentMomentValue,
+  type DataCubeOperationValue,
+} from '../DataCubeQueryEngine.js';
 import type { DataCubeSnapshotFilterCondition } from '../DataCubeSnapshot.js';
 import type { DataCubeColumn } from '../model/DataCubeColumn.js';
 import { type V1_AppliedFunction } from '@finos/legend-graph';
@@ -52,6 +56,16 @@ export abstract class DataCubeQueryFilterOperation {
     ) {
       return undefined;
     }
+    // NOTE: `isCompatibleWithValue()` cannot tell whether a current-moment
+    // value (`today()`/`now()`) makes sense for the column it is compared
+    // against, since it does not have access to the column, so check here that
+    // the column actually carries a date.
+    if (
+      isCurrentMomentValue(value) &&
+      !getCurrentMomentValueType(column.type)
+    ) {
+      return undefined;
+    }
     return {
       ...column,
       operator: this.operator,

package/src/stores/core/filter/DataCubeQueryFilterOperation__Equal.tsx

@@ -23,6 +23,7 @@ import {
   isPrimitiveType,
   ofDataType,
   _defaultPrimitiveTypeValue,
+  isCurrentMomentValue,
   type DataCubeOperationValue,
 } from '../DataCubeQueryEngine.js';
 import {
@@ -62,6 +63,12 @@ export class DataCubeQueryFilterOperation__Equal extends DataCubeQueryFilterOper
   }
 
   isCompatibleWithValue(value: DataCubeOperationValue) {
+    // current-moment values (`today()`/`now()`) are date values resolved at
+    // execution time; the column they apply to is checked in
+    // `_finalizeConditionSnapshot()`
+    if (isCurrentMomentValue(value)) {
+      return true;
+    }
     return (
       value.value !== undefined &&
       isPrimitiveType(value.type) &&