@finos/legend-cube-builder 0.0.2 → 0.0.4

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);
+  }
+}

package/src/stores/editors/CubeRenameDraft.ts

@@ -0,0 +1,110 @@
+/**
+ * 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 { Rename, RenameMapping } from '@finos/legend-cube';
+import { action, makeObservable, observable } from 'mobx';
+import { CubeNodeDraft } from './CubeNodeDraft.js';
+
+/** One row of the Rename editor: an old column and its new name, `''` until picked or typed */
+export interface CubeRenameRow {
+  /** Identifies the row in the editor */
+  readonly key: number;
+  readonly from: string;
+  readonly to: string;
+}
+
+let nextRowKey = 1;
+
+const blankRow = (): CubeRenameRow => ({ key: nextRowKey++, from: '', to: '' });
+
+const isSameMappings = (
+  a: readonly RenameMapping[],
+  b: readonly RenameMapping[],
+): boolean =>
+  a.length === b.length &&
+  a.every(
+    (mapping, index) =>
+      mapping.from === b[index]?.from && mapping.to === b[index]?.to,
+  );
+
+/**
+ * The Rename editor's draft (spec §17.6: a list of old column and new name
+ * rows). A new name is kept exactly as typed, never trimmed. A row with
+ * neither name is left out when built, as a Filter's blank rows are; a row
+ * with only one is kept, so validation reports it.
+ */
+export class CubeRenameDraft extends CubeNodeDraft<Rename> {
+  rows: readonly CubeRenameRow[];
+  /** Anything was changed; until then, `build()` gives the original back */
+  private touched = false;
+
+  constructor(original: Rename) {
+    super(original);
+    makeObservable<CubeRenameDraft, 'touched'>(this, {
+      rows: observable.ref,
+      touched: observable,
+      addRow: action,
+      removeRow: action,
+      setFrom: action,
+      setTo: action,
+    });
+    this.rows = original.mappings.length
+      ? original.mappings.map(({ from, to }) => ({
+          key: nextRowKey++,
+          from,
+          to,
+        }))
+      : [blankRow()];
+  }
+
+  /** The mappings the rows build, in order: a row with neither name is left out */
+  get mappings(): RenameMapping[] {
+    return this.rows
+      .filter((row) => row.from || row.to)
+      .map(({ from, to }) => ({ from, to }));
+  }
+
+  addRow(): void {
+    this.rows = [...this.rows, blankRow()];
+    this.touched = true;
+  }
+
+  removeRow(key: number): void {
+    this.rows = this.rows.filter((row) => row.key !== key);
+    this.touched = true;
+  }
+
+  setFrom(key: number, from: string): void {
+    this.rows = this.rows.map((row) =>
+      row.key === key ? { ...row, from } : row,
+    );
+    this.touched = true;
+  }
+
+  setTo(key: number, to: string): void {
+    this.rows = this.rows.map((row) =>
+      row.key === key ? { ...row, to } : row,
+    );
+    this.touched = true;
+  }
+
+  build(): Rename {
+    const { original, mappings } = this;
+    return !this.touched || isSameMappings(mappings, original.mappings)
+      ? original
+      : original.withMappings(mappings);
+  }
+}

package/src/stores/editors/CubeRestrictDraft.ts

@@ -0,0 +1,83 @@
+/**
+ * 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 { Restrict, Schema } from '@finos/legend-cube';
+import { action, makeObservable, observable } from 'mobx';
+import { CubeNodeDraft } from './CubeNodeDraft.js';
+
+/**
+ * The columns in the input's order, then those the input doesn't have, in
+ * the order they were picked: a saved column the input lost stays listed
+ * until it is unticked
+ */
+const inInputOrder = (names: readonly string[], schema: Schema): string[] => [
+  ...schema.names().filter((name) => names.includes(name)),
+  ...names.filter((name) => schema.lookup(name) === undefined),
+];
+
+const isSameSet = (a: readonly string[], b: readonly string[]): boolean =>
+  a.length === b.length && a.every((name) => b.includes(name));
+
+/**
+ * The Restrict editor's draft (spec §17.6: a multi-select of the columns to
+ * keep). It keeps the picked columns in the input's order, as the node's
+ * output has them.
+ */
+export class CubeRestrictDraft extends CubeNodeDraft<Restrict> {
+  columns: readonly string[];
+  /** Anything was changed; until then, `build()` gives the original back */
+  private touched = false;
+
+  constructor(original: Restrict) {
+    super(original);
+    makeObservable<CubeRestrictDraft, 'touched'>(this, {
+      columns: observable.ref,
+      touched: observable,
+      toggleColumn: action,
+      selectAll: action,
+      clear: action,
+    });
+    this.columns = original.columns;
+  }
+
+  /** Ticks or unticks the column */
+  toggleColumn(name: string, schema: Schema): void {
+    this.columns = this.columns.includes(name)
+      ? this.columns.filter((picked) => picked !== name)
+      : inInputOrder([...this.columns, name], schema);
+    this.touched = true;
+  }
+
+  /** Ticks every column of the input */
+  selectAll(schema: Schema): void {
+    this.columns = inInputOrder([...schema.names(), ...this.columns], schema);
+    this.touched = true;
+  }
+
+  /** Unticks every column */
+  clear(): void {
+    this.columns = [];
+    this.touched = true;
+  }
+
+  /** The original while the same columns are picked, whatever their order */
+  build(): Restrict {
+    const { original, columns } = this;
+    return !this.touched || isSameSet(columns, original.columns)
+      ? original
+      : original.withColumns(columns);
+  }
+}

package/src/stores/editors/CubeRowCountDraft.ts

@@ -0,0 +1,69 @@
+/**
+ * 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';
+import { action, makeObservable, observable } from 'mobx';
+import { parseWholeNumberText } from './CubeIntegerText.js';
+import { CubeNodeDraft } from './CubeNodeDraft.js';
+
+/** A node whose one setting is a number of rows: a Limit or a Drop */
+export interface CubeRowCountNode<N extends QueryNode> extends QueryNode {
+  readonly size: number | undefined;
+  withSize(size: number | undefined): N;
+}
+
+/**
+ * The draft of a node whose one setting is a number of rows (spec §17.6: "one
+ * integer field"). It keeps the text as typed. Text that isn't a whole
+ * number, empty text included, builds a cleared size, which the node reports:
+ * never the default (spec §7.7). The text it opened with gives the original
+ * back, so a saved size the field can't read (`1.5` from an imported spec) is
+ * kept unless the user types something else.
+ */
+export class CubeRowCountDraft<
+  N extends CubeRowCountNode<N>,
+> extends CubeNodeDraft<N> {
+  sizeText: string;
+  /** The text the field opened with, which builds the original */
+  private readonly initialText: string;
+
+  constructor(original: N) {
+    super(original);
+    makeObservable(this, {
+      sizeText: observable,
+      setSizeText: action,
+    });
+    this.initialText = original.size === undefined ? '' : String(original.size);
+    this.sizeText = this.initialText;
+  }
+
+  /** The size the text gives: `undefined` unless it is a whole number */
+  get size(): number | undefined {
+    return parseWholeNumberText(this.sizeText);
+  }
+
+  setSizeText(text: string): void {
+    this.sizeText = text;
+  }
+
+  /** The original while the field holds its opening text or the same size */
+  build(): N {
+    const { original, size } = this;
+    return this.sizeText.trim() === this.initialText || size === original.size
+      ? original
+      : original.withSize(size);
+  }
+}

package/src/stores/editors/CubeSliceDraft.ts

@@ -0,0 +1,87 @@
+/**
+ * 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 { Slice } from '@finos/legend-cube';
+import { action, makeObservable, observable } from 'mobx';
+import { parseWholeNumberText } from './CubeIntegerText.js';
+import { CubeNodeDraft } from './CubeNodeDraft.js';
+
+const textOf = (value: number | undefined): string =>
+  value === undefined ? '' : String(value);
+
+/**
+ * The Slice editor's draft (spec §17.6: start and stop integer fields). It
+ * keeps the texts as typed; a text that isn't a whole number builds a
+ * cleared bound, which the node reports, never the default (spec §7.9). A
+ * field that holds the text it opened with keeps its saved bound, so a bound
+ * the field can't read (`1.5` from an imported spec) is kept unless the user
+ * types something else in that field.
+ */
+export class CubeSliceDraft extends CubeNodeDraft<Slice> {
+  startText: string;
+  stopText: string;
+  /** The texts the fields opened with, which keep the saved bounds */
+  private readonly initialStartText: string;
+  private readonly initialStopText: string;
+
+  constructor(original: Slice) {
+    super(original);
+    makeObservable(this, {
+      startText: observable,
+      stopText: observable,
+      setStartText: action,
+      setStopText: action,
+    });
+    this.initialStartText = textOf(original.start);
+    this.initialStopText = textOf(original.stop);
+    this.startText = this.initialStartText;
+    this.stopText = this.initialStopText;
+  }
+
+  /** The start the text gives: `undefined` unless it is a whole number */
+  get start(): number | undefined {
+    return parseWholeNumberText(this.startText);
+  }
+
+  /** The stop the text gives: `undefined` unless it is a whole number */
+  get stop(): number | undefined {
+    return parseWholeNumberText(this.stopText);
+  }
+
+  setStartText(text: string): void {
+    this.startText = text;
+  }
+
+  setStopText(text: string): void {
+    this.stopText = text;
+  }
+
+  /** The original while each field holds its opening text or the same bound */
+  build(): Slice {
+    const { original, start, stop } = this;
+    const keepStart =
+      this.startText.trim() === this.initialStartText ||
+      start === original.start;
+    const keepStop =
+      this.stopText.trim() === this.initialStopText || stop === original.stop;
+    return keepStart && keepStop
+      ? original
+      : original.withRange(
+          keepStart ? original.start : start,
+          keepStop ? original.stop : stop,
+        );
+  }
+}

package/src/stores/editors/CubeSortDraft.ts

@@ -0,0 +1,98 @@
+/**
+ * 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 ColumnDirection,
+  type Sort,
+  type SortDirection,
+} from '@finos/legend-cube';
+import { action, makeObservable, observable } from 'mobx';
+import { CubeNodeDraft } from './CubeNodeDraft.js';
+import {
+  blankSortRow,
+  type CubeSortRow,
+  isSameSorts,
+  movedSortRows,
+  sortKeysOfRows,
+  sortRowsOf,
+  sortsOfRows,
+} from './CubeSortRows.js';
+
+/**
+ * The Sort editor's draft (spec §17.6: a list of column and direction rows,
+ * most significant first). A row without a column is left out when built, as
+ * a Rename's blank rows are. While the rows are the ones it opened with, the
+ * original is given back, so a saved key without a column (from an imported
+ * spec) is kept until the rows change; removing its row removes it.
+ */
+export class CubeSortDraft extends CubeNodeDraft<Sort> {
+  rows: readonly CubeSortRow[];
+  /** The rows' keys when the editor opened, blank ones included */
+  private readonly initialKeys: readonly ColumnDirection[];
+
+  constructor(original: Sort) {
+    super(original);
+    makeObservable(this, {
+      rows: observable.ref,
+      addRow: action,
+      removeRow: action,
+      moveRow: action,
+      setColumn: action,
+      setDirection: action,
+    });
+    this.rows = original.sorts.length
+      ? sortRowsOf(original.sorts)
+      : [blankSortRow()];
+    this.initialKeys = sortKeysOfRows(this.rows);
+  }
+
+  /** The keys the rows build, in order: a row without a column is left out */
+  get sorts(): ColumnDirection[] {
+    return sortsOfRows(this.rows);
+  }
+
+  addRow(): void {
+    this.rows = [...this.rows, blankSortRow()];
+  }
+
+  removeRow(key: number): void {
+    this.rows = this.rows.filter((row) => row.key !== key);
+  }
+
+  /** Moves a row one place up (`-1`) or down (`1`), if it can go there */
+  moveRow(key: number, offset: -1 | 1): void {
+    this.rows = movedSortRows(this.rows, key, offset);
+  }
+
+  setColumn(key: number, column: string): void {
+    this.rows = this.rows.map((row) =>
+      row.key === key ? { ...row, column } : row,
+    );
+  }
+
+  setDirection(key: number, direction: SortDirection): void {
+    this.rows = this.rows.map((row) =>
+      row.key === key ? { ...row, direction } : row,
+    );
+  }
+
+  build(): Sort {
+    const { original } = this;
+    return isSameSorts(sortKeysOfRows(this.rows), this.initialKeys)
+      ? original
+      : original.withSorts(this.sorts);
+  }
+}