@finos/legend-cube-builder 0.0.2 → 0.0.3

package/src/stores/CubeNodeEditorState.ts

@@ -14,7 +14,14 @@
  * limitations under the License.
  */
 
-import type { NodeRegistry, QueryNode } from '@finos/legend-cube';
+import {
+  canFixJoinDuplicates,
+  fixJoinDuplicates,
+  type NodeRegistry,
+  type Query,
+  type QueryNode,
+  type Schema,
+} from '@finos/legend-cube';
 import {
   action,
   computed,
@@ -87,8 +94,10 @@ export class CubeNodeEditorState {
       hasChanges: computed,
       open: action,
       canSwapInputs: computed,
+      canRenameDuplicateColumns: computed,
       apply: action,
       swapInputs: action,
+      renameDuplicateColumns: action,
       close: action,
       cancel: action,
       discard: action,
@@ -190,6 +199,66 @@ export class CubeNodeEditorState {
     this.bind(query.getNode(node.id) ?? node);
   }
 
+  /**
+   * The cube's query with the draft in place of its node, when it has
+   * changes, and the schemas of the node's inputs, which the draft doesn't
+   * change
+   */
+  private get queryWithEdits(): {
+    query: Query;
+    inputSchemas: (Schema | undefined)[];
+  } {
+    const { node, edited } = this;
+    let { query } = this.editorState.document;
+    if (edited && this.hasChanges && query.canReplace(edited)) {
+      query = query.replace(edited);
+    }
+    return {
+      query,
+      inputSchemas: node
+        ? query
+            .getInputIds(node.id)
+            .map((inputId) =>
+              inputId === undefined
+                ? undefined
+                : this.editorState.analysis.schemas.get(inputId),
+            )
+        : [],
+    };
+  }
+
+  /**
+   * Whether the join being edited, edits included, can have the columns its
+   * inputs share renamed (spec §7.11's autofix, PLAN §11.4): its only problem
+   * is the duplicate rule, and the cube isn't read-only
+   */
+  get canRenameDuplicateColumns(): boolean {
+    const { node } = this;
+    if (!node || node.key !== this.nodeKey || this.editorState.readOnly) {
+      return false;
+    }
+    const { query, inputSchemas } = this.queryWithEdits;
+    const [leftSchema, rightSchema] = inputSchemas;
+    return canFixJoinDuplicates(query, node.id, leftSchema, rightSchema);
+  }
+
+  /**
+   * Renames the columns the join's inputs share with a Rename before each
+   * input, applying the draft first, as one undo step, then goes on editing
+   * the join, whose keys follow the renames
+   */
+  renameDuplicateColumns(): void {
+    const { node } = this;
+    if (!node || !this.canRenameDuplicateColumns) {
+      return;
+    }
+    const { query, inputSchemas } = this.queryWithEdits;
+    const [leftSchema, rightSchema] = inputSchemas;
+    const fixed = fixJoinDuplicates(query, node.id, leftSchema, rightSchema);
+    this.editorState.applyQuery(fixed);
+    this.bind(fixed.getNode(node.id) ?? node);
+  }
+
   /** Applies the draft, then closes the panel (spec §17.5: edits commit on close) */
   close(): void {
     this.apply();

package/src/stores/CubeShowPureState.ts

@@ -14,8 +14,9 @@
  * limitations under the License.
  */
 
+import { needsDatabaseType } from '@finos/legend-cube';
 import type { GeneratorFn } from '@finos/legend-shared';
-import { action, flow, makeObservable, observable } from 'mobx';
+import { action, flow, flowResult, makeObservable, observable } from 'mobx';
 import {
   CubeEngineError,
   CubeEngineErrorKind,
@@ -50,11 +51,18 @@ export class CubeShowPureState {
     this.editorState = editorState;
   }
 
-  /** Opens the dialog and renders the query; does nothing when Execute can't run */
+  /**
+   * Opens the dialog and renders the query, written for the database it runs
+   * on, as Execute writes it; does nothing when Execute can't run
+   */
   *open(): GeneratorFn<void> {
     const { execution, document, emitter, rowLimit, host } = this.editorState;
-    const runtime = document.context?.runtime;
-    if (!execution.canExecute || runtime === undefined) {
+    const { query, context } = document;
+    const runtime = context?.runtime;
+    const model = context?.model;
+    // checked by canExecute
+    const captureId = query.selected as string;
+    if (!execution.canExecute || runtime === undefined || model === undefined) {
       return;
     }
     const request = ++this.request;
@@ -63,8 +71,22 @@ export class CubeShowPureState {
     this.error = undefined;
     this.isRendering = true;
     try {
+      let databaseType: string | undefined;
+      if (needsDatabaseType(query, captureId)) {
+        yield flowResult(this.editorState.loadModelOutline(model));
+        // closed, or opened again, while the outline loaded
+        if (request !== this.request) {
+          return;
+        }
+        databaseType = this.editorState.getRunDatabaseType(
+          query,
+          captureId,
+          model,
+          runtime,
+        );
+      }
       const text = (yield host.engine.renderPure(
-        emitter.emitExecutionLambda({ rowLimit, runtime }),
+        emitter.emitExecutionLambda({ rowLimit, runtime, databaseType }),
       )) as string;
       if (request === this.request) {
         this.text = text;

package/src/stores/editors/CubeIntegerText.ts

@@ -0,0 +1,34 @@
+/**
+ * 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.
+ */
+
+/** Whole-number text: an optional sign, then digits */
+const WHOLE_NUMBER_TEXT = /^[+-]?\d+$/u;
+
+/**
+ * The number a size or row index field holds. Text that isn't a whole number,
+ * empty text included, gives `undefined`, which the node then reports: never
+ * a default. It doesn't use `Number()` on the raw text, which reads `''` as 0,
+ * `0x10` as 16 and `1e3` as 1000. Spaces around the digits are allowed; a
+ * number too long for a double gives `undefined`.
+ */
+export const parseWholeNumberText = (text: string): number | undefined => {
+  const trimmed = text.trim();
+  if (!WHOLE_NUMBER_TEXT.test(trimmed)) {
+    return undefined;
+  }
+  const value = Number(trimmed);
+  return Number.isFinite(value) ? value : undefined;
+};

package/src/stores/editors/CubeJoinDraft.ts

@@ -20,6 +20,7 @@ import {
   JoinType,
   type Query,
   RelationalTableSource,
+  Rename,
   type SchemaInferenceResult,
 } from '@finos/legend-cube';
 import { action, makeObservable, observable } from 'mobx';
@@ -138,28 +139,42 @@ export class CubeJoinDraft extends CubeNodeDraft<Join> {
   }
 }
 
+/** 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 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 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 column the node's output
+ * doesn't have, e.g. one a Restrict dropped, comes from nowhere.
  */
-export const findColumnSources = (
+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;
+  const inputName =
+    node instanceof Rename
+      ? (node.mappings.find(({ to }) => to === columnName)?.from ?? columnName)
+      : columnName;
   const followed =
     node instanceof Join &&
     node.joinType !== JoinType.FULL_OUTER &&
@@ -169,12 +184,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 +214,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/CubeNodeDraftRegistry.ts

@@ -14,12 +14,28 @@
  * limitations under the License.
  */
 
-import { Filter, Join, type QueryNode } from '@finos/legend-cube';
+import {
+  Distinct,
+  Drop,
+  Filter,
+  Join,
+  Limit,
+  type QueryNode,
+  Rename,
+  Restrict,
+  Slice,
+  Sort,
+} from '@finos/legend-cube';
 import { guaranteeType } from '@finos/legend-shared';
 import type { CubeEditorState } from '../CubeEditorState.js';
 import { CubeFilterDraft } from './CubeFilterDraft.js';
 import { CubeJoinDraft } from './CubeJoinDraft.js';
 import { type CubeNodeDraft, CubeReadOnlyNodeDraft } from './CubeNodeDraft.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 +52,28 @@ export const CUBE_NODE_DRAFT_FACTORIES: ReadonlyMap<
   string,
   CubeNodeDraftFactory
 > = new Map<string, CubeNodeDraftFactory>([
+  [Sort.TYPE, (node) => new CubeSortDraft(guaranteeType(node, Sort))],
   [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))],
 ]);
 
+/**
+ * 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,

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