@finos/legend-cube-builder 0.0.4 → 0.0.5

package/src/__lib__/LegendCubeHelpText.ts

@@ -21,15 +21,19 @@ import {
   IngestDatasetSource,
   Distinct,
   Drop,
+  ExpressionFilter,
   Extend,
   Filter,
+  FunctionSource,
   Group,
   Join,
   Limit,
   Partition,
+  Pivot,
   RelationalTableSource,
   Rename,
   Restrict,
+  ServiceSource,
   Slice,
   Sort,
   UnknownNode,
@@ -42,12 +46,18 @@ import {
 
 export const CUBE_NODE_HELP_TEXT: Readonly<Record<string, string>> = {
   [RelationalTableSource.TYPE]: 'Sources data from relational database table.',
+  /** Added by Cube: the original's PURE Native Function source (PLAN §6.5) */
+  [FunctionSource.TYPE]:
+    'Sources data from a function of the model that returns a relation, called with a value for each parameter.',
   /** Added by Cube: the original has no data product source (PLAN §6.8) */
   [DataProductAccessPointSource.TYPE]:
     'Sources data from an access point of a deployed data product.',
   /** Added by Cube: the original has no ingest data set source (PLAN §6.7) */
   [IngestDatasetSource.TYPE]:
     'Sources data from a data set of a deployed ingest definition.',
+  /** Added by Cube: the original's service source is read another way, still to come (PLAN §6.4) */
+  [ServiceSource.TYPE]:
+    "Sources data from a deployed service. In progress: Cube can't read services yet.",
   [Concat.TYPE]:
     'Combines the rows of the two previous data sets, keeping duplicates, in no particular order. Both must have the same columns: the same names, in the same order, with the same types.',
   [Difference.TYPE]:
@@ -59,8 +69,14 @@ export const CUBE_NODE_HELP_TEXT: Readonly<Record<string, string>> = {
     'Extends outgoing data set with new columns produced by expressions.',
   [Filter.TYPE]:
     'Reduces the number of rows in the previous data set, keeping only rows matching the specified criteria.',
+  /** Added by Cube: the original has no filter by expression (PLAN §11.11) */
+  [ExpressionFilter.TYPE]:
+    'Reduces the number of rows in the previous data set, keeping only rows for which the expression is true.',
   [Group.TYPE]:
     'Aggregates the data from the previous data set using the specified columns and aggregation functions.',
+  /** Added by Cube: the original has pivot only in the grid (PLAN §11.12) */
+  [Pivot.TYPE]:
+    'Turns the values of a column of the previous data set into columns: a row for each combination of the row columns that has a picked value, and a column for each picked value, holding its aggregate.',
   [Join.TYPE]:
     'Joins two previous data sets using specified columns as join keys.',
   [Partition.TYPE]:
@@ -79,4 +95,10 @@ export const CUBE_NODE_HELP_TEXT: Readonly<Record<string, string>> = {
 
 /** The tooltip of the editor's Select link (spec §17.9) */
 export const SELECT_NODE_TOOLTIP =
-  'Selects this node as active and its output will be shown in the grid once query is executed.';
+  'Make this the step that runs: Execute shows its rows in the grid.';
+
+/** The marker on the step that runs, on the canvas and in its editor */
+export const RUNNING_NODE_LABEL = 'Runs';
+
+/** What a node's menu and editor call making it the step that runs */
+export const RUN_THIS_STEP_LABEL = 'Run this step';

package/src/__lib__/LegendCubeLabels.ts

@@ -14,7 +14,11 @@
  * limitations under the License.
  */
 
-import type { SchemaColumn, SchemaDiff } from '@finos/legend-cube';
+import {
+  type SchemaColumn,
+  type SchemaDiff,
+  TypeFamily,
+} from '@finos/legend-cube';
 import { CubeTableFlag } from '../graph-manager/CubeEngine.js';
 
 // The page's own text and settings; validation messages live in the core's
@@ -32,6 +36,10 @@ export enum LEGEND_CUBE_USER_DATA_KEY {
   PALETTE_COLLAPSED = 'legend-cube.palette-collapsed',
   /** The warehouse the viewer last picked for a data product cube (PLAN §6.8) */
   DATA_PRODUCT_WAREHOUSE = 'legend-cube.data-product-warehouse',
+  /** Server-side or local (PLAN §11.10) */
+  GRID_MODE = 'legend-cube.grid-mode',
+  /** Engine requests sent uncompressed, for the browser's Network tab (PLAN §11.16) */
+  UNCOMPRESSED_REQUESTS = 'legend-cube.uncompressed-requests',
 }
 
 export const UNSAVED_CUBE_NAME = 'Unsaved Query';
@@ -49,26 +57,51 @@ export const READ_ONLY_CUBE_TITLE =
 /** How a SQL NULL shows in the grid, distinct from an empty string */
 export const NULL_CELL_TEXT = '(null)';
 
+/** What the Runs panel calls a run (PLAN §11.10, §11.16); a fetch of the grid's rows is described by its level */
+export const CUBE_RUN_LABEL = {
+  EXECUTE: 'Execute',
+  EXPORT_CSV: 'Export CSV',
+  pivotValues: (column: string): string => `Values of ${column}`,
+};
+
+/**
+ * Above a run's Pure (PLAN §11.16): unlike Show Pure, it shows the limit a
+ * grid run adds, one more than the row limit, to tell whether there are more
+ */
+export const CUBE_RUN_PURE_NOTE =
+  'As it ran, with any row limit Cube added to it.';
+
 /** Pending labels: lower-case gerunds, shown as they are (spec §17.13) */
 export enum CUBE_PENDING_LABEL {
   LOADING_MODEL = 'loading model',
   RESOLVING_SOURCE = 'resolving source',
   EXECUTING_QUERY = 'executing query',
+  FETCHING_ROWS = 'fetching rows',
+  EXPORTING_CSV = 'exporting CSV',
   RENDERING_QUERY = 'rendering query',
   REFRESHING_SOURCE = 'refreshing source',
-  TYPING_COLUMNS = 'typing new columns',
+  CHECKING_EXPRESSIONS = 'checking expressions',
 }
 
-export const getRowLimitError = (text: string): string | undefined => {
-  const value = Number(text.trim());
-  return text.trim() === '' || !Number.isSafeInteger(value) || value < 1
+/**
+ * Why a row limit can't be taken: the number its text holds
+ * (`parseWholeNumberText`, so `0x10`, `1e3` and `1.0` hold none, PLAN
+ * §11.14) isn't a safe whole number of at least 1
+ */
+export const getRowLimitError = (
+  value: number | undefined,
+): string | undefined =>
+  value === undefined || !Number.isSafeInteger(value) || value < 1
     ? 'The row limit must be a whole number of at least 1.'
     : undefined;
-};
 
 export const getTruncationMessage = (rowLimit: number): string =>
   `Showing the first ${rowLimit.toLocaleString('en-US')} rows; the query returned more.`;
 
+/** In server-side mode, when a drill-down level or a sorted level was cut at the row limit (PLAN §11.10) */
+export const getLevelTruncationMessage = (rowLimit: number): string =>
+  `Some levels show only their first ${rowLimit.toLocaleString('en-US')} rows or groups.`;
+
 /** How the picker shows a table's problem, and why (PLAN §6.2.6) */
 export const CUBE_TABLE_FLAG_LABELS: Readonly<
   Record<CubeTableFlag, { label: string; description: string }>
@@ -87,10 +120,36 @@ export const CUBE_TABLE_FLAG_LABELS: Readonly<
   },
 };
 
-/** A column's type as the editors show it: its display name, `?` when it takes NULL, e.g. `Varchar(5)?` */
-export const getColumnTypeLabel = (column: SchemaColumn): string =>
+/** A column's exact type: its display name, `?` when it takes NULL, e.g. `Varchar(5)?`; for hover and type messages */
+export const getExactColumnTypeLabel = (column: SchemaColumn): string =>
   `${column.type.displayName}${column.nullable ? '?' : ''}`;
 
+/** The kind of value a type family holds, as the editors name it (the review of the demo, 2026-10-13) */
+const TYPE_FAMILY_LABELS: Partial<Record<TypeFamily, string>> = {
+  [TypeFamily.BOOLEAN]: 'True or false',
+  [TypeFamily.STRING]: 'Text',
+  [TypeFamily.INTEGER]: 'Whole number',
+  [TypeFamily.FLOAT]: 'Number',
+  [TypeFamily.DECIMAL]: 'Decimal',
+  [TypeFamily.NUMBER]: 'Number',
+  [TypeFamily.STRICT_DATE]: 'Date',
+  [TypeFamily.DATETIME]: 'Date and time',
+  [TypeFamily.DATE]: 'Date',
+  [TypeFamily.STRICT_TIME]: 'Time',
+  [TypeFamily.VARIANT]: 'Variant',
+};
+
+/**
+ * A column's type as the editors show it: the kind of value, and whether it
+ * can be empty, e.g. `Text, can be empty`; an enumeration, or a type Cube
+ * doesn't know, by its name. The exact type (`getExactColumnTypeLabel`) is
+ * on hover.
+ */
+export const getColumnTypeLabel = (column: SchemaColumn): string =>
+  `${TYPE_FAMILY_LABELS[column.type.family] ?? column.type.displayName}${
+    column.nullable ? ', can be empty' : ''
+  }`;
+
 const listColumns = (columns: readonly SchemaColumn[]): string =>
   columns.map((column) => column.name).join(', ');
 
@@ -108,7 +167,7 @@ export const getSchemaChangeList = (diff: SchemaDiff): string => {
           `changed ${diff.changed
             .map(
               (change) =>
-                `${change.after.name} (${getColumnTypeLabel(change.before)} to ${getColumnTypeLabel(change.after)})`,
+                `${change.after.name} (${getExactColumnTypeLabel(change.before)} to ${getExactColumnTypeLabel(change.after)})`,
             )
             .join(', ')}`,
         ]
@@ -136,6 +195,11 @@ export const CUBE_QUICK_ACTION_DISABLED_REASON = {
   EDITING:
     "Close the node editor first: these rows don't show the changes in it.",
   UNREADABLE_VALUE: "This value can't be used in a filter.",
+  /** On a group row's cell that holds its aggregation (PLAN §11.10) */
+  AGGREGATE_VALUE:
+    "This cell holds its group's aggregation, not a row's value, so it can't be used in a filter.",
+  /** On a group row's cell that shows nothing */
+  NO_VALUE: 'This cell has no value to filter by.',
   notSortable: (typeName: string): string =>
     `Values of type ${typeName} can't be sorted.`,
   notGroupable: (typeName: string): string =>
@@ -144,6 +208,16 @@ export const CUBE_QUICK_ACTION_DISABLED_REASON = {
     `Values of type ${typeName} can't be compared.`,
 };
 
+/** Why 'Format Column' can't be used on a column (spec §13.1) */
+export const CUBE_FORMAT_NOT_A_NUMBER = 'Only number columns can be formatted.';
+
+/** Why 'Drilldown by' can't be used on a column (PLAN §11.10) */
+export const CUBE_DRILLDOWN_BLOCKER = {
+  ALREADY_A_LEVEL: 'The results already drill down by this column.',
+  notGroupable: (typeName: string): string =>
+    `Values of type ${typeName} can't be grouped.`,
+};
+
 /** Beside a condition comparing a floating-point column for equality (R133) */
 export const FILTER_FLOAT_COMPARISON_HINT =
   'exact comparison on floating-point columns may not match';
@@ -241,6 +315,42 @@ export const GROUP_EDITOR_NOTES = [
   'With no group column, the result is one row, even when there are no rows.',
 ];
 
+/** Why the Pivot editor won't take a column (PLAN §11.12), shown after the column's type */
+export const PIVOT_COLUMN_DISABLED_REASON = {
+  /** a row column that can't be compared */
+  NOT_GROUPABLE: "can't be grouped",
+  /** a pivot column of another type than a String, an integer, a StrictDate or a Boolean */
+  NOT_PIVOTABLE: "can't be pivoted",
+  /** a column the pivot uses for another part */
+  PIVOT_COLUMN: 'the pivot column',
+  ROW_COLUMN: 'a row column',
+  AGGREGATED: 'the aggregated column',
+} as const;
+
+/** Why the Pivot editor won't tick a value (PLAN §11.12) */
+export const PIVOT_VALUE_DISABLED_REASON = {
+  NOT_A_COLUMN_NAME: "can't name a column",
+  /** another value ticked has the same text in another case */
+  DIFFERS_ONLY_IN_CASE: 'only its case differs from a ticked value',
+  /** as many values are ticked as a Pivot takes */
+  TOO_MANY: 'as many values as a Pivot takes are ticked',
+} as const;
+
+/** What the Pivot editor says (PLAN §11.12) */
+export const PIVOT_EDITOR_NOTES = [
+  'Each picked value becomes a column, named by the value, holding the aggregation of its rows; each combination of the row columns with a picked value becomes a row. Values not picked, and combinations holding only them, are left out.',
+  "Load values lists the pivot column's values, each once, up to 100. An empty value can't be pivoted, nor one that can't name a column; of two values that differ only in case, one can be ticked, as some databases would mix up their columns.",
+  "Pivot runs on Snowflake, Databricks, SingleStore and DuckDB; other databases, such as H2 and Postgres, can't run it.",
+] as const;
+
+/** Says that Load values found no value to list (PLAN §11.12) */
+export const PIVOT_NO_VALUES_NOTICE =
+  'The pivot column has no value to list: its rows are all empty, or there are none.';
+
+/** Says that the engine has more values than the Pivot editor lists (PLAN §11.12) */
+export const getPivotValuesCutNotice = (shown: number): string =>
+  `Only the first ${shown} values are listed.`;
+
 /** Why the Partition editor won't tick a column that can't be compared (PLAN §11.6) */
 export const CUBE_PARTITION_COLUMN_DISABLED_REASON = "can't be partitioned by";
 
@@ -295,6 +405,10 @@ export const EXTEND_APPLY_DISABLED_REASON = Object.freeze({
 export const getExtendRetypeWarning = (firstLine: string): string =>
   `Could not check these columns' types again, so they keep their saved ones: ${firstLine}`;
 
+/** The warning on a Filter by Expression whose condition the engine couldn't check again, e.g. offline (PLAN §11.11) */
+export const getConditionRecheckWarning = (firstLine: string): string =>
+  `Could not check this condition again, so it keeps its last check: ${firstLine}`;
+
 /** The notice of a node editor kept open, since its changes can't be applied yet, e.g. an Extend's expressions not validated */
 export const getEditorKeptOpenNotice = (
   nodeId: string,
@@ -302,11 +416,34 @@ export const getEditorKeptOpenNotice = (
 ): string =>
   `The editor of ${nodeId} stays open, since its changes can't be applied yet: ${waiting}, or Cancel to drop them.`;
 
+/** Why the Filter by Expression editor's Apply waits (PLAN §11.11) */
+export const EXPRESSION_FILTER_APPLY_DISABLED_REASON = Object.freeze({
+  NOT_VALIDATED: 'Validate the condition first (F10)',
+  VALIDATING: 'Validating the condition',
+});
+
+/**
+ * The hint after an engine error on `and`, `or` or `not` given something
+ * other than a Boolean, which Pure's precedence usually causes: comparisons
+ * bind no tighter than `&&`, `||` and `!` (PLAN §11.11)
+ */
+export const EXPRESSION_FILTER_PARENTHESES_HINT =
+  'Put each comparison in parentheses: ($x.A > 1) && ($x.B > 3).';
+
+/** What the Filter by Expression editor says about conditions (PLAN §11.11) */
+export const EXPRESSION_FILTER_EDITOR_NOTES = [
+  "A condition of one row, written as in Query's text mode: x | $x.SHIPPED_DATE > $x.REQUIRED_DATE. The rows for which it is true are kept, in their order.",
+  'Put each comparison in parentheses when you combine them: ($x.A > 1) && ($x.B > 3). In Pure, &&, || and ! bind as tightly as >, <, >= and <=; == binds tighter.',
+  'A column that can be empty, compared directly ($x.A > 6), fails the condition when it is empty and passes its negation. After ->toOne(), an empty value fails both.',
+  "Validate (F10) checks the condition with the engine and plans it for the cube's database.",
+  "startsWith, endsWith and contains can't take a value with a backslash (\\) yet, nor, on DuckDB, one with % or _.",
+] as const;
+
 /** The hint after an engine error on a column that can be empty, in arithmetic (PLAN §11.7) */
 export const EXTEND_TO_ONE_HINT =
   'A column that can be empty needs ->toOne() first, such as $x.QTY->toOne() + 1.';
 
-/** The problem a database refusing an Extend's plan gives (PLAN §11.7) */
+/** The problem a database refusing an Extend's or a Filter by Expression's plan gives (PLAN §11.7, §11.11) */
 export const getExtendPlanProblem = (
   databaseType: string | undefined,
   detail: string,
@@ -317,13 +454,33 @@ export const getExtendPlanProblem = (
 export const COLUMN_NAME_RULES_HINT =
   'Names can\'t start or end with a space, or contain " or \\ or control characters, and have at most 128 characters.';
 
+/** Words a title leaves in lower case, but first */
+const TITLE_SMALL_WORDS = new Set(['a', 'an', 'of']);
+
 /**
  * A node type's label as the node editor's title shows it, each word
- * capitalised (QUESTIONS.md U1(a)), e.g. 'Take First <x> Rows'; the registry
- * keeps its own wording
+ * capitalised but `a`, `an` and `of` (QUESTIONS.md U1(a)), e.g. 'Take a Range
+ * of Rows'; the registry keeps its own wording
  */
 export const toEditorTitle = (label: string): string =>
-  label.replace(/(?<=^|\s)[a-z]/gu, (letter) => letter.toUpperCase());
+  label.replace(/(?<=^|\s)[a-z]+/gu, (word, offset: number) =>
+    offset > 0 && TITLE_SMALL_WORDS.has(word)
+      ? word
+      : `${word[0]?.toUpperCase() ?? ''}${word.slice(1)}`,
+  );
 
 /** The source dialog's body until a tab is chosen, opened from the empty canvas (spec §17.8, U4(b)) */
 export const SELECT_SOURCE_TYPE_PROMPT = 'Select source type above';
+
+/** Why the source dialog's Add is disabled: nothing picked yet, or not ready */
+export const CUBE_PICK_TO_ADD_TITLE = 'Pick what to add first';
+
+/**
+ * The badge a node type shows beside its name: WIP for one that doesn't
+ * work yet (a service, PLAN §6.4), else BETA for one in beta, else none
+ */
+export const getCubeNodeBadge = (definition: {
+  readonly beta: boolean;
+  readonly wip?: boolean | undefined;
+}): 'WIP' | 'BETA' | undefined =>
+  definition.wip ? 'WIP' : definition.beta ? 'BETA' : undefined;

package/src/__lib__/LegendCubeProjectSourceLabels.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) 2026-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.
+ */
+
+/**
+ * What the source dialog says on a host that reads one project's own
+ * sources (`CubeHost.project`), e.g. Studio
+ */
+export const CUBE_PROJECT_SOURCE_LABEL = {
+  RUNS_ON: (runtime: string): string => `Runs on ${runtime}`,
+  READING_RUNTIME: "reading the project's lakehouse runtime",
+  NO_INGEST_DEFINITIONS: 'The project has no ingest definitions.',
+  NO_DATA_PRODUCTS: 'The project has no data products.',
+} as const;

package/src/__lib__/LegendCubeServiceLabels.ts

@@ -0,0 +1,41 @@
+/**
+ * Copyright (c) 2026-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 { MESSAGE_SERVICE_NOT_READABLE } from '@finos/legend-cube';
+
+// The text of service sources (PLAN §6.4), in progress: the source dialog's
+// Service tab and a service's panel
+
+export const CUBE_SERVICE_MESSAGE = {
+  /** Why a service source isn't valid yet: its first line is the node's error */
+  NOT_READABLE: `${MESSAGE_SERVICE_NOT_READABLE}\nPicking a service works; reading its columns and rows is still being built.`,
+  NO_CATALOG: "This Legend deployment doesn't list services",
+  CUBE_CHANGED:
+    'The cube changed while the service was being added; pick it again.',
+  NONE: 'No services are deployed.',
+  NO_MATCH: 'No service matches the search.',
+  IN_PROGRESS:
+    "Services are in progress: a service can be added to the canvas, but Cube can't read it yet.",
+} as const;
+
+/** How many of the matching services the tab shows, when it doesn't show them all */
+export const getShownServicesLabel = (
+  shown: number,
+  matching: number,
+): string | undefined =>
+  shown < matching
+    ? `Showing ${shown} of ${matching} services: search to narrow the list`
+    : undefined;

package/src/__lib__/LegendCubeTesting.ts

@@ -15,6 +15,7 @@
  */
 
 export enum LEGEND_CUBE_TEST_ID {
+  RUNNING_NODE_BADGE = 'legend-cube__running-node-badge',
   EDITOR = 'legend-cube__editor',
   GRAPH_REGION = 'legend-cube__graph-region',
   GRID_REGION = 'legend-cube__grid-region',
@@ -26,8 +27,14 @@ export enum LEGEND_CUBE_TEST_ID {
   NODE_EDITOR = 'legend-cube__node-editor',
   EDITOR_NOTICE = 'legend-cube__editor-notice',
   ENTRY_SOURCE_ERROR = 'legend-cube__entry-source-error',
+  LAMBDA_IMPORT = 'legend-cube__lambda-import',
+  IMPORT_PURE = 'legend-cube__import-pure',
   FILTER_CONDITION = 'legend-cube__filter-condition',
   RESULT_GRID = 'legend-cube__result-grid',
+  DRILLDOWN_BAR = 'legend-cube__drilldown-bar',
+  RUN_STATS = 'legend-cube__run-stats',
+  COLUMN_FORMAT = 'legend-cube__column-format',
+  DRILLDOWN_SETTINGS = 'legend-cube__drilldown-settings',
   GRID_TOOLBAR = 'legend-cube__grid-toolbar',
   EXECUTION_ERROR = 'legend-cube__execution-error',
   SQL_PANEL = 'legend-cube__sql-panel',

package/src/__test-utils__/CubeEngineTestSupport.ts

@@ -117,13 +117,14 @@ export const CUBE_ENGINE_TEST__jsonToGrammar_lambda = async (
  */
 export const CUBE_ENGINE_TEST__execute = async (
   input: object | string,
+  serializationFormat = 'DEFAULT',
 ): Promise<{ ok: boolean; status: number; text: () => Promise<string> }> => {
   const response = await axios.post<unknown, AxiosResponse<string>>(
     `${PURE_API}/execution/execute`,
     input,
     {
       headers: JSON_HEADERS,
-      params: { serializationFormat: 'DEFAULT' },
+      params: { serializationFormat },
       responseType: 'text',
       transformResponse: (data: string) => data,
       validateStatus: () => true,

package/src/__test-utils__/CubeExpressionTestUtils.ts

@@ -16,15 +16,18 @@
 
 import {
   buildSchemasAndValidity,
+  ExpressionFilter,
   Extend,
+  getExpressionFilterSignature,
   getExtendSignature,
   type JsonObject,
   PrimitiveType,
   type Query,
 } from '@finos/legend-cube';
 
-// Extend columns for tests (PLAN §11.7), written as the engine's JSON, as a
-// column stores it: number literals as their digits
+// Extend columns and filter conditions for tests (PLAN §11.7, §11.11),
+// written as the engine's JSON, as a node stores it: number literals as their
+// digits
 
 /** `x | <body>` and the pieces of a body */
 export const TEST__expression = {
@@ -54,6 +57,7 @@ export const TEST__expression = {
     _type: 'integer',
     value: String(value),
   }),
+  string: (value: string): JsonObject => ({ _type: 'string', value }),
 };
 
 /** A new column: its name, its lambda, and the type the engine gives it */
@@ -88,6 +92,29 @@ export const TEST__typedExtend = (
   });
 };
 
+/**
+ * A Filter by Expression of this condition, checked for the input Cube infers
+ * for `input`'s selected node, so it is valid without the engine; the engine
+ * tests check the engine takes it. With an invalid input, not checked.
+ */
+export const TEST__checkedExpressionFilter = (
+  id: string,
+  input: Query,
+  code: string,
+  lambda: JsonObject,
+): ExpressionFilter => {
+  const filter = new ExpressionFilter(id, code, lambda);
+  const schema = buildSchemasAndValidity(input).schemas.get(
+    input.selected ?? '',
+  );
+  return schema
+    ? filter.withCheck({
+        kind: 'checked',
+        signature: getExpressionFilterSignature(schema, lambda),
+      })
+    : filter;
+};
+
 /** `a: x | $x.ORDER_ID + 1` and `b: x | $x.a * 2`, the second using the first, both Integer */
 export const TEST__ORDER_ID_EXTEND_COLUMNS: readonly TEST__ExtendColumn[] = [
   [

package/src/__test-utils__/CubeFunctionTestOutline.ts

@@ -0,0 +1,78 @@
+/**
+ * Copyright (c) 2026-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 { resolveCubeType, Schema, SchemaColumn } from '@finos/legend-cube';
+import type {
+  CubeModelOutline,
+  CubeOutlineFunction,
+} from '../graph-manager/CubeEngine.js';
+import {
+  NORTHWIND_DATABASE,
+  NORTHWIND_RUNTIME,
+} from './CubeNorthwindTestQueries.js';
+import { FAKE_NORTHWIND_OUTLINE } from './FakeCubeEngine.js';
+
+// The fake Northwind outline with functions that return a relation (PLAN
+// §6.5), and a second runtime: one function of each kind
+
+export const ARCHIVE_RUNTIME = 'northwind::ArchiveRuntime';
+
+const fn = (
+  name: string,
+  parameters: CubeOutlineFunction['parameters'] = [],
+  extra: Partial<CubeOutlineFunction> = {},
+): CubeOutlineFunction => ({
+  path: `northwind::${name}`,
+  signature: `northwind::${name}__Relation_1_`,
+  parameters,
+  columns: [{ name: 'ORDER_ID', type: 'Integer' }],
+  ...extra,
+});
+
+export const ALL_ORDERS = fn('allOrders');
+export const ORDERS_ABOVE = fn('ordersAbove', [
+  { name: 'min', type: 'Float', multiplicity: '[1]' },
+  { name: 'status', type: 'String', multiplicity: '[0..1]' },
+]);
+export const SHIPPED = fn('shipped', [], { runtime: NORTHWIND_RUNTIME });
+export const ARCHIVED = fn('archived', [], { runtime: ARCHIVE_RUNTIME });
+export const ORDERS_OF = fn(
+  'ordersOf',
+  [{ name: 'ids', type: 'Integer', multiplicity: '[*]' }],
+  {
+    problem:
+      'Its parameter "ids" takes [*] values; Cube takes one value, or none',
+  },
+);
+
+export const FUNCTIONS_OUTLINE: CubeModelOutline = {
+  ...FAKE_NORTHWIND_OUTLINE,
+  runtimes: [
+    ...FAKE_NORTHWIND_OUTLINE.runtimes,
+    {
+      path: ARCHIVE_RUNTIME,
+      storePaths: [NORTHWIND_DATABASE],
+      connections: [
+        { storePath: NORTHWIND_DATABASE, databaseType: 'Postgres' },
+      ],
+    },
+  ],
+  functions: [ALL_ORDERS, ORDERS_ABOVE, SHIPPED, ARCHIVED, ORDERS_OF],
+};
+
+export const FUNCTION_SCHEMA = new Schema([
+  new SchemaColumn('ORDER_ID', resolveCubeType('Integer'), true),
+]);