@finos/legend-cube-builder 0.0.3 → 0.0.4

package/src/stores/editors/CubeJoinDraft.ts

@@ -15,9 +15,15 @@
  */
 
 import {
+  AggregationFunction,
+  Difference,
+  DifferenceSuffix,
   getSameNamedJoinKeys,
+  Group,
+  isWindowRowFunction,
   Join,
   JoinType,
+  Partition,
   type Query,
   RelationalTableSource,
   Rename,
@@ -25,35 +31,25 @@ import {
 } from '@finos/legend-cube';
 import { action, makeObservable, observable } from 'mobx';
 import type { CubeModelOutline } from '../../graph-manager/CubeEngine.js';
+import { isSameList } from './CubeAggregationRows.js';
+import {
+  blankJoinKeyPair,
+  type CubeJoinKeyPair,
+  type CubeJoinKeysDraft,
+  joinKeyListsOf,
+  joinKeyPairsOf,
+} from './CubeJoinKeyPairs.js';
 import { CubeNodeDraft } from './CubeNodeDraft.js';
 
-/** One pair of key columns, matched by position; `''` until a column is picked */
-export interface CubeJoinKeyPair {
-  /** Identifies the row in the editor */
-  readonly key: number;
-  readonly left: string;
-  readonly right: string;
-}
-
-let nextPairKey = 1;
-
-const isSameList = (a: readonly string[], b: readonly string[]): boolean =>
-  a.length === b.length && a.every((name, index) => name === b[index]);
-
-/** The key lists pairs build: a pair with no column picked is left out */
-const toKeyLists = (
-  pairs: readonly CubeJoinKeyPair[],
-): [string[], string[]] => {
-  const kept = pairs.filter((pair) => pair.left || pair.right);
-  return [kept.map((pair) => pair.left), kept.map((pair) => pair.right)];
-};
-
 /**
  * The Join editor's draft (spec §17.6): the join type and the key column
  * pairs. A pair with no column picked on either side is left out when built,
  * as a Filter's blank rows are (user's choice, 2026-10-07).
  */
-export class CubeJoinDraft extends CubeNodeDraft<Join> {
+export class CubeJoinDraft
+  extends CubeNodeDraft<Join>
+  implements CubeJoinKeysDraft
+{
   joinType: JoinType;
   pairs: CubeJoinKeyPair[];
   /** Anything was changed; until then, `build()` gives the original back */
@@ -77,20 +73,8 @@ export class CubeJoinDraft extends CubeNodeDraft<Join> {
       setRightColumn: action,
     });
     this.joinType = original.joinType;
-    this.pairs = Array.from(
-      {
-        length: Math.max(
-          original.leftColumns.length,
-          original.rightColumns.length,
-        ),
-      },
-      (_, index) => ({
-        key: nextPairKey++,
-        left: original.leftColumns[index] ?? '',
-        right: original.rightColumns[index] ?? '',
-      }),
-    );
-    this.initialKeyLists = toKeyLists(this.pairs);
+    this.pairs = joinKeyPairsOf(original.leftColumns, original.rightColumns);
+    this.initialKeyLists = joinKeyListsOf(this.pairs);
   }
 
   setJoinType(joinType: JoinType): void {
@@ -99,7 +83,7 @@ export class CubeJoinDraft extends CubeNodeDraft<Join> {
   }
 
   addPair(): void {
-    this.pairs = [...this.pairs, { key: nextPairKey++, left: '', right: '' }];
+    this.pairs = [...this.pairs, blankJoinKeyPair()];
     this.touched = true;
   }
 
@@ -123,7 +107,7 @@ export class CubeJoinDraft extends CubeNodeDraft<Join> {
   }
 
   build(): Join {
-    const [leftColumns, rightColumns] = toKeyLists(this.pairs);
+    const [leftColumns, rightColumns] = joinKeyListsOf(this.pairs);
     const [initialLeft, initialRight] = this.initialKeyLists;
     const { original } = this;
     return !this.touched ||
@@ -139,6 +123,82 @@ export class CubeJoinDraft extends CubeNodeDraft<Join> {
   }
 }
 
+/** The aggregations whose output is one of their column's values, so typed as it (PLAN §11.5) */
+const VALUE_AGGREGATIONS: readonly string[] = [
+  AggregationFunction.DISTINCT_VALUE,
+  AggregationFunction.MIN,
+  AggregationFunction.MAX,
+];
+
+/**
+ * The input column a Group's output column comes from: a key by its name, a
+ * Distinct Value, Min or Max by its aggregated column; a count, a sum or an
+ * average is no column's value, so it comes from none
+ */
+const groupInputName = (
+  group: Group,
+  columnName: string,
+): string | undefined => {
+  if (group.columns.includes(columnName)) {
+    return columnName;
+  }
+  const aggregation = group.aggregations.find(
+    ({ name }) => name === columnName,
+  );
+  return aggregation && VALUE_AGGREGATIONS.includes(aggregation.function)
+    ? aggregation.column
+    : undefined;
+};
+
+/**
+ * The input column a Partition's output column comes from: an input column by
+ * its name, a Distinct Value, Min or Max, or a Lag, Lead, First or Last (PLAN
+ * §11.9), by its column, whose values it holds; a count, a sum, an average or
+ * a rank is no column's value, so it comes from none
+ */
+const partitionInputName = (
+  partition: Partition,
+  columnName: string,
+): string | undefined => {
+  const aggregation = partition.aggregations.find(
+    ({ name }) => name === columnName,
+  );
+  if (!aggregation) {
+    return columnName;
+  }
+  return VALUE_AGGREGATIONS.includes(aggregation.function) ||
+    isWindowRowFunction(aggregation.function)
+    ? aggregation.column
+    : undefined;
+};
+
+/**
+ * Where a Difference's output column comes from: `x_1` from the Left input's
+ * `x`, `x_2` from the Right input's, a key or another column from the inputs
+ * that have it (both for a key of the same name, which the full outer join
+ * merges); `x_valueDifference` is no column's value, so it comes from none
+ */
+const differenceInputOf = (
+  difference: Difference,
+  columnName: string,
+): { name: string; side?: 'left' | 'right' } | undefined => {
+  const of = (suffix: DifferenceSuffix): string | undefined =>
+    difference.differenceColumns.find(
+      (name) => `${name}${suffix}` === columnName,
+    );
+  const left = of(DifferenceSuffix.LEFT);
+  if (left !== undefined) {
+    return { name: left, side: 'left' };
+  }
+  const right = of(DifferenceSuffix.RIGHT);
+  if (right !== undefined) {
+    return { name: right, side: 'right' };
+  }
+  return of(DifferenceSuffix.DIFFERENCE) === undefined
+    ? { name: columnName }
+    : undefined;
+};
+
 /** Where a column of a node's output comes from: a table, and the column's name in it */
 export interface CubeColumnOrigin {
   readonly source: RelationalTableSource;
@@ -150,8 +210,13 @@ export interface CubeColumnOrigin {
  * through the inputs whose output has it, and through a Rename to its old
  * name. A join key of the same name on both sides comes from the side the
  * join keeps (the left for INNER and LEFT OUTER, the right for RIGHT OUTER),
- * and from both for FULL OUTER, which merges them. A column the node's output
- * doesn't have, e.g. one a Restrict dropped, comes from nowhere.
+ * and from both for FULL OUTER, which merges them. A Group's key comes from
+ * its column, and a Distinct Value, Min or Max from the column it aggregates,
+ * as a Partition's do; a Partition's input columns come from its input. A
+ * Difference's `x_1` and `x_2` come from `x` on their side. A column the node's
+ * output doesn't have, e.g. one a Restrict dropped, or a Group's or
+ * Partition's count, sum, average or rank, or a Difference's difference,
+ * comes from nowhere.
  */
 export const findColumnOrigins = (
   query: Query,
@@ -171,10 +236,34 @@ export const findColumnOrigins = (
   }
   const inputIds = query.getInputIds(nodeId);
   const [leftId, rightId] = inputIds;
+  if (node instanceof Difference) {
+    const input = differenceInputOf(node, columnName);
+    if (!input) {
+      return [];
+    }
+    const sides =
+      input.side === 'left'
+        ? [leftId]
+        : input.side === 'right'
+          ? [rightId]
+          : inputIds;
+    return sides.flatMap((inputId) =>
+      inputId !== undefined && analysis.schemas.get(inputId)?.lookup(input.name)
+        ? findColumnOrigins(query, analysis, inputId, input.name)
+        : [],
+    );
+  }
   const inputName =
     node instanceof Rename
       ? (node.mappings.find(({ to }) => to === columnName)?.from ?? columnName)
-      : columnName;
+      : node instanceof Group
+        ? groupInputName(node, columnName)
+        : node instanceof Partition
+          ? partitionInputName(node, columnName)
+          : columnName;
+  if (inputName === undefined) {
+    return [];
+  }
   const followed =
     node instanceof Join &&
     node.joinType !== JoinType.FULL_OUTER &&

package/src/stores/editors/CubeJoinKeyPairs.ts

@@ -0,0 +1,68 @@
+/**
+ * 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 type { QueryNode } from '@finos/legend-cube';
+
+// The key column pairs of the editors that join two inputs (Join, spec §17.6;
+// Difference, PLAN §11.7)
+
+/** One pair of key columns, matched by position; `''` until a column is picked */
+export interface CubeJoinKeyPair {
+  /** Identifies the row in the editor */
+  readonly key: number;
+  readonly left: string;
+  readonly right: string;
+}
+
+let nextPairKey = 1;
+
+export const blankJoinKeyPair = (): CubeJoinKeyPair => ({
+  key: nextPairKey++,
+  left: '',
+  right: '',
+});
+
+/** The pairs of saved key lists, by position; a list longer than the other pairs its extra columns with `''` */
+export const joinKeyPairsOf = (
+  leftColumns: readonly string[],
+  rightColumns: readonly string[],
+): CubeJoinKeyPair[] =>
+  Array.from(
+    { length: Math.max(leftColumns.length, rightColumns.length) },
+    (_, index) => ({
+      key: nextPairKey++,
+      left: leftColumns[index] ?? '',
+      right: rightColumns[index] ?? '',
+    }),
+  );
+
+/** The key lists pairs build: a pair with no column picked is left out */
+export const joinKeyListsOf = (
+  pairs: readonly CubeJoinKeyPair[],
+): [string[], string[]] => {
+  const kept = pairs.filter((pair) => pair.left || pair.right);
+  return [kept.map((pair) => pair.left), kept.map((pair) => pair.right)];
+};
+
+/** A draft whose node joins its inputs on pairs of key columns: a Join's or a Difference's */
+export interface CubeJoinKeysDraft {
+  readonly original: QueryNode;
+  readonly pairs: readonly CubeJoinKeyPair[];
+  addPair(): void;
+  removePair(key: number): void;
+  setLeftColumn(key: number, left: string): void;
+  setRightColumn(key: number, right: string): void;
+}

package/src/stores/editors/CubeNodeDraft.ts

@@ -17,14 +17,15 @@
 import type { QueryNode } from '@finos/legend-cube';
 
 /**
- * The edits of one node in the side panel, kept until Apply (PLAN §7.4,
- * spec §17.5). A node type's editor edits its draft, never the document:
- * only the panel's Apply stores `build()`, as one undo step. A draft is
- * made once each time the panel opens on a node, and again after an Apply.
+ * The edits of one node in the node editor, kept until Apply or closing it
+ * (PLAN §7.4, §11.8, spec §17.5). A node type's editor edits its draft,
+ * never the document: only Apply, or closing the editor any way but Cancel,
+ * stores `build()`, as one undo step. A draft is made once each time the
+ * editor opens on a node, and again after an Apply.
  */
 export abstract class CubeNodeDraft<N extends QueryNode = QueryNode> {
-  /** The node the draft was made from */
-  readonly original: N;
+  /** The node the draft was made from; `follow` may move it on */
+  original: N;
 
   constructor(original: N) {
     this.original = original;
@@ -36,6 +37,25 @@ export abstract class CubeNodeDraft<N extends QueryNode = QueryNode> {
    * as no change.
    */
   abstract build(): N;
+
+  /**
+   * Why Apply waits, if it does: the panel disables it with this reason and
+   * shows it in place of the problems, e.g. an Extend whose expressions
+   * aren't validated yet (PLAN §11.7)
+   */
+  get applyDisabledReason(): string | undefined {
+    return undefined;
+  }
+
+  /**
+   * Whether the draft goes on, made from this node, when the node it was
+   * made from is replaced underneath it by one that differs in nothing the
+   * draft edits, e.g. an Extend the engine typed in the background; else
+   * the panel drops the edits (PLAN §7.4)
+   */
+  follow(node: QueryNode): boolean {
+    return false;
+  }
 }
 
 /** A node with nothing to edit in the panel, such as a source or an Unknown node */

package/src/stores/editors/CubeNodeDraftRegistry.ts

@@ -15,11 +15,16 @@
  */
 
 import {
+  Concat,
+  Difference,
   Distinct,
   Drop,
+  Extend,
   Filter,
+  Group,
   Join,
   Limit,
+  Partition,
   type QueryNode,
   Rename,
   Restrict,
@@ -28,9 +33,14 @@ import {
 } from '@finos/legend-cube';
 import { guaranteeType } from '@finos/legend-shared';
 import type { CubeEditorState } from '../CubeEditorState.js';
+import { CubeConcatDraft } from './CubeConcatDraft.js';
+import { CubeDifferenceDraft } from './CubeDifferenceDraft.js';
+import { CubeExtendDraft } from './CubeExtendDraft.js';
 import { CubeFilterDraft } from './CubeFilterDraft.js';
+import { CubeGroupDraft } from './CubeGroupDraft.js';
 import { CubeJoinDraft } from './CubeJoinDraft.js';
 import { type CubeNodeDraft, CubeReadOnlyNodeDraft } from './CubeNodeDraft.js';
+import { CubePartitionDraft } from './CubePartitionDraft.js';
 import { CubeRenameDraft } from './CubeRenameDraft.js';
 import { CubeRestrictDraft } from './CubeRestrictDraft.js';
 import { CubeRowCountDraft } from './CubeRowCountDraft.js';
@@ -53,6 +63,7 @@ export const CUBE_NODE_DRAFT_FACTORIES: ReadonlyMap<
   CubeNodeDraftFactory
 > = new Map<string, CubeNodeDraftFactory>([
   [Sort.TYPE, (node) => new CubeSortDraft(guaranteeType(node, Sort))],
+  [Group.TYPE, (node) => new CubeGroupDraft(guaranteeType(node, Group))],
   [Filter.TYPE, (node) => new CubeFilterDraft(guaranteeType(node, Filter))],
   [
     Restrict.TYPE,
@@ -63,6 +74,20 @@ export const CUBE_NODE_DRAFT_FACTORIES: ReadonlyMap<
   [Drop.TYPE, (node) => new CubeRowCountDraft(guaranteeType(node, Drop))],
   [Limit.TYPE, (node) => new CubeRowCountDraft(guaranteeType(node, Limit))],
   [Slice.TYPE, (node) => new CubeSliceDraft(guaranteeType(node, Slice))],
+  [Concat.TYPE, (node) => new CubeConcatDraft(guaranteeType(node, Concat))],
+  [
+    Difference.TYPE,
+    (node) => new CubeDifferenceDraft(guaranteeType(node, Difference)),
+  ],
+  [
+    Partition.TYPE,
+    (node) => new CubePartitionDraft(guaranteeType(node, Partition)),
+  ],
+  [
+    Extend.TYPE,
+    (node, editorState) =>
+      new CubeExtendDraft(guaranteeType(node, Extend), editorState),
+  ],
 ]);
 
 /**

package/src/stores/editors/CubePartitionDraft.ts

@@ -0,0 +1,214 @@
+/**
+ * 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 type {
+  AggregationSetting,
+  AggregationUse,
+  ColumnAggregation,
+  ColumnDirection,
+  Partition,
+  Schema,
+  SortDirection,
+} from '@finos/legend-cube';
+import { action, computed, makeObservable, observable } from 'mobx';
+import {
+  aggregationRowsOf,
+  aggregationsOfRows,
+  blankAggregationRow,
+  type CubeAggregationRow,
+  isBuiltAggregationRow,
+  isSameAggregations,
+  isSameList,
+  toggledColumns,
+  withRowColumn,
+  withRowFunction,
+  withRowName,
+  withRowSetting,
+} from './CubeAggregationRows.js';
+import { CubeNodeDraft } from './CubeNodeDraft.js';
+import {
+  blankSortRow,
+  type CubeSortRow,
+  isSameSorts,
+  movedSortRows,
+  sortRowsOf,
+  sortsOfRows,
+} from './CubeSortRows.js';
+
+/**
+ * The Partition editor's draft (spec §17.6, PLAN §11.6): rows of window
+ * function column, function and output name, as a Group's (one blank row to
+ * start), the partition columns, stored in the input's order but kept in a
+ * saved order until the picks change (M4's Q2), and sort rows, as a Sort's
+ * (none to start). A row's name follows its column and function until typed.
+ * Picking a column first sets Count; Count rows and the rank functions clear
+ * the column, which they can't hold. Lag and Lead take an offset, NTile a
+ * bucket count, typed as text and given their defaults when picked (PLAN
+ * §11.9). Until something changes, `build()`
+ * gives the original back, a saved sort key without a column included.
+ */
+export class CubePartitionDraft extends CubeNodeDraft<Partition> {
+  columns: readonly string[];
+  sortRows: readonly CubeSortRow[];
+  rows: readonly CubeAggregationRow[];
+  /** Anything was changed; until then, `build()` gives the original back */
+  private touched = false;
+
+  constructor(original: Partition) {
+    super(original);
+    makeObservable<CubePartitionDraft, 'touched'>(this, {
+      columns: observable.ref,
+      sortRows: observable.ref,
+      rows: observable.ref,
+      touched: observable,
+      sorts: computed,
+      aggregationUse: computed,
+      aggregations: computed,
+      toggleColumn: action,
+      clearColumns: action,
+      addSortRow: action,
+      removeSortRow: action,
+      moveSortRow: action,
+      setSortColumn: action,
+      setSortDirection: action,
+      addRow: action,
+      removeRow: action,
+      setColumn: action,
+      setFunction: action,
+      setSetting: action,
+      setName: action,
+    });
+    this.columns = original.columns;
+    this.sortRows = sortRowsOf(original.sorts);
+    this.rows = aggregationRowsOf(
+      original.aggregations,
+      original.aggregationUse,
+    );
+  }
+
+  /** The sort keys the rows build, in order: a row without a column is left out */
+  get sorts(): ColumnDirection[] {
+    return sortsOfRows(this.sortRows);
+  }
+
+  /** Where the rows' functions are: a window, sorted when a sort row has a column */
+  get aggregationUse(): AggregationUse {
+    return { kind: 'window', sorted: this.sorts.length > 0 };
+  }
+
+  /** The window functions the rows build, in order (`isBuiltAggregationRow`) */
+  get aggregations(): ColumnAggregation[] {
+    return aggregationsOfRows(this.rows, this.aggregationUse);
+  }
+
+  /** Whether a row builds a window function */
+  isBuiltRow(row: CubeAggregationRow): boolean {
+    return isBuiltAggregationRow(row, this.aggregationUse);
+  }
+
+  /** Ticks or unticks a partition column; the columns then follow the input's order */
+  toggleColumn(name: string, schema: Schema): void {
+    this.columns = toggledColumns(this.columns, name, schema);
+    this.touched = true;
+  }
+
+  /** Unticks every partition column: one window over all the rows */
+  clearColumns(): void {
+    this.columns = [];
+    this.touched = true;
+  }
+
+  addSortRow(): void {
+    this.sortRows = [...this.sortRows, blankSortRow()];
+    this.touched = true;
+  }
+
+  removeSortRow(key: number): void {
+    this.sortRows = this.sortRows.filter((row) => row.key !== key);
+    this.touched = true;
+  }
+
+  /** Moves a sort row one place up (`-1`) or down (`1`), if it can go there */
+  moveSortRow(key: number, offset: -1 | 1): void {
+    this.sortRows = movedSortRows(this.sortRows, key, offset);
+    this.touched = true;
+  }
+
+  setSortColumn(key: number, column: string): void {
+    this.sortRows = this.sortRows.map((row) =>
+      row.key === key ? { ...row, column } : row,
+    );
+    this.touched = true;
+  }
+
+  setSortDirection(key: number, direction: SortDirection): void {
+    this.sortRows = this.sortRows.map((row) =>
+      row.key === key ? { ...row, direction } : row,
+    );
+    this.touched = true;
+  }
+
+  addRow(): void {
+    this.rows = [...this.rows, blankAggregationRow()];
+    this.touched = true;
+  }
+
+  removeRow(key: number): void {
+    this.rows = this.rows.filter((row) => row.key !== key);
+    this.touched = true;
+  }
+
+  private update(
+    key: number,
+    change: (row: CubeAggregationRow) => CubeAggregationRow,
+  ): void {
+    this.rows = this.rows.map((row) => (row.key === key ? change(row) : row));
+    this.touched = true;
+  }
+
+  /** Picks the row's column; with no function yet, Count */
+  setColumn(key: number, column: string): void {
+    this.update(key, (row) => withRowColumn(row, column, this.aggregationUse));
+  }
+
+  /** Picks the row's function: Count rows and the rank functions take no column, the others one */
+  setFunction(key: number, fn: string): void {
+    this.update(key, (row) => withRowFunction(row, fn, this.aggregationUse));
+  }
+
+  /** Types the row's setting, Lag's and Lead's offset or NTile's bucket count, kept as text (PLAN §11.9) */
+  setSetting(key: number, setting: AggregationSetting, text: string): void {
+    this.update(key, (row) => withRowSetting(row, setting, text));
+  }
+
+  /** Types the row's name, kept exactly; the auto-name itself follows again */
+  setName(key: number, name: string): void {
+    this.update(key, (row) => withRowName(row, name, this.aggregationUse));
+  }
+
+  build(): Partition {
+    const { original, columns, sorts, aggregations } = this;
+    return !this.touched ||
+      (isSameList(columns, original.columns) &&
+        isSameSorts(sorts, original.sorts) &&
+        isSameAggregations(aggregations, original.aggregations))
+      ? original
+      : original
+          .withColumns(columns)
+          .withSorts(sorts)
+          .withAggregations(aggregations);
+  }
+}