@finos/legend-cube-builder 0.0.2 → 0.0.4

package/src/stores/editors/CubeJoinDraft.ts

@@ -15,44 +15,41 @@
  */
 
 import {
+  AggregationFunction,
+  Difference,
+  DifferenceSuffix,
   getSameNamedJoinKeys,
+  Group,
+  isWindowRowFunction,
   Join,
   JoinType,
+  Partition,
   type Query,
   RelationalTableSource,
+  Rename,
   type SchemaInferenceResult,
 } 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 */
@@ -76,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 {
@@ -98,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;
   }
 
@@ -122,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 ||
@@ -138,28 +123,147 @@ 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 table sources a column of a node's output comes from: followed back
- * through the inputs whose output has the column. 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.
+ * 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
  */
-export const findColumnSources = (
+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;
+  readonly column: string;
+}
+
+/**
+ * The table columns a column of a node's output comes from: followed back
+ * 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 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,
   analysis: SchemaInferenceResult,
   nodeId: string,
   columnName: string,
-): RelationalTableSource[] => {
+): CubeColumnOrigin[] => {
   const node = query.getNode(nodeId);
   if (node instanceof RelationalTableSource) {
     return node.resolution.kind === 'resolved' &&
       node.resolution.schema.lookup(columnName)
-      ? [node]
+      ? [{ source: node, column: columnName }]
       : [];
   }
+  if (!node || !analysis.schemas.get(nodeId)?.lookup(columnName)) {
+    return [];
+  }
   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)
+      : 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 &&
@@ -169,12 +273,23 @@ export const findColumnSources = (
       ? [node.joinType === JoinType.RIGHT_OUTER ? rightId : leftId]
       : inputIds;
   return followed.flatMap((inputId) =>
-    inputId !== undefined && analysis.schemas.get(inputId)?.lookup(columnName)
-      ? findColumnSources(query, analysis, inputId, columnName)
+    inputId !== undefined && analysis.schemas.get(inputId)?.lookup(inputName)
+      ? findColumnOrigins(query, analysis, inputId, inputName)
       : [],
   );
 };
 
+/** The table sources a column of a node's output comes from (`findColumnOrigins`) */
+export const findColumnSources = (
+  query: Query,
+  analysis: SchemaInferenceResult,
+  nodeId: string,
+  columnName: string,
+): RelationalTableSource[] =>
+  findColumnOrigins(query, analysis, nodeId, columnName).map(
+    ({ source }) => source,
+  );
+
 /**
  * Whether the column of the node's output comes from a table column whose
  * type Cube can't read (OTHER or ARRAY), so it was typed as a bare String
@@ -188,10 +303,11 @@ export const isUntypedColumn = (
   columnName: string,
 ): boolean =>
   outline !== undefined &&
-  findColumnSources(query, analysis, nodeId, columnName).some((source) =>
-    outline.databases
-      .find((database) => database.path === source.database)
-      ?.schemas.find((schema) => schema.name === source.schema)
-      ?.tables.find((table) => table.name === source.table)
-      ?.untypedColumns.includes(columnName),
+  findColumnOrigins(query, analysis, nodeId, columnName).some(
+    ({ source, column }) =>
+      outline.databases
+        .find((database) => database.path === source.database)
+        ?.schemas.find((schema) => schema.name === source.schema)
+        ?.tables.find((table) => table.name === source.table)
+        ?.untypedColumns.includes(column),
   );

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

@@ -14,12 +14,38 @@
  * limitations under the License.
  */
 
-import { Filter, Join, type QueryNode } from '@finos/legend-cube';
+import {
+  Concat,
+  Difference,
+  Distinct,
+  Drop,
+  Extend,
+  Filter,
+  Group,
+  Join,
+  Limit,
+  Partition,
+  type QueryNode,
+  Rename,
+  Restrict,
+  Slice,
+  Sort,
+} 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';
+import { CubeSliceDraft } from './CubeSliceDraft.js';
+import { CubeSortDraft } from './CubeSortDraft.js';
 
 /** Makes the draft of a node of one type */
 export type CubeNodeDraftFactory = (
@@ -36,10 +62,43 @@ export const CUBE_NODE_DRAFT_FACTORIES: ReadonlyMap<
   string,
   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,
+    (node) => new CubeRestrictDraft(guaranteeType(node, Restrict)),
+  ],
+  [Rename.TYPE, (node) => new CubeRenameDraft(guaranteeType(node, Rename))],
   [Join.TYPE, (node) => new CubeJoinDraft(guaranteeType(node, Join))],
+  [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),
+  ],
 ]);
 
+/**
+ * The transforms with nothing to set (spec §17.6: Distinct is "description
+ * only"): an editor in `CUBE_NODE_EDITORS` and no draft factory, so the panel
+ * shows no Apply or Cancel (PLAN §7.4 item 2)
+ */
+export const CUBE_NODE_TYPES_WITHOUT_SETTINGS: readonly string[] = [
+  Distinct.TYPE,
+];
+
 /** The node's draft; a node with nothing to edit gets a read-only one */
 export const createCubeNodeDraft = (
   node: QueryNode,