@finos/legend-cube-builder 0.0.2 → 0.0.4

package/src/stores/CubeNodeEditorState.ts

@@ -14,7 +14,18 @@
  * limitations under the License.
  */
 
-import type { NodeRegistry, QueryNode } from '@finos/legend-cube';
+import {
+  canFixJoinDuplicates,
+  canRenameConcatInput,
+  canRestrictConcatInput,
+  fixJoinDuplicates,
+  type NodeRegistry,
+  type Query,
+  type QueryNode,
+  renameConcatInput,
+  restrictConcatInput,
+  type Schema,
+} from '@finos/legend-cube';
 import {
   action,
   computed,
@@ -26,6 +37,7 @@ import {
 import {
   CUBE_EDITOR_CLOSED_REASON,
   getEditorClosedNotice,
+  getEditorKeptOpenNotice,
 } from '../__lib__/LegendCubeLabels.js';
 import type { CubeEditorState } from './CubeEditorState.js';
 import type { CubeNodeDraft } from './editors/CubeNodeDraft.js';
@@ -54,9 +66,11 @@ export const isSameNodeContent = (
 };
 
 /**
- * The node editor in the side panel (PLAN §7.4, spec §17.5). Opening it
- * never changes which node Execute runs. Edits go to a draft, and only Apply,
- * or closing the panel, stores them, as one undo step; Cancel drops them.
+ * The node editor (PLAN §7.4, §11.8, spec §17.5). Opening it never changes
+ * which node Execute runs. Edits go to a draft, and only Apply, or closing
+ * the editor, stores them, as one undo step; Cancel drops them. Every close
+ * that applies goes through `finish`, which first lets the editor's fields
+ * commit text typed but not yet stored.
  *
  * The panel follows the cube (user's choice, 2026-10-07): when the node it
  * shows is replaced or removed underneath it, by Undo, a re-check or a
@@ -73,13 +87,27 @@ export class CubeNodeEditorState {
   draft: CubeNodeDraft | undefined;
   /** Why the panel closed by itself, until it opens again or is dismissed */
   notice: string | undefined;
+  /** A node the keyboard goes back to, once its editor closed from the keyboard */
+  nodeToFocus: string | undefined;
+  /** How many dropdowns, pickers or dialogs opened from the editor hold it open */
+  private holds = 0;
+  /** What commits the editor's pending input, e.g. a field's text not yet stored, in order */
+  private flushers: { flush: () => void; isPending: () => boolean }[] = [];
 
   private readonly disposeSync: IReactionDisposer;
 
   constructor(editorState: CubeEditorState) {
-    makeObservable<CubeNodeEditorState, 'nodeKey' | 'sync'>(this, {
+    makeObservable<CubeNodeEditorState, 'nodeKey' | 'holds' | 'sync'>(this, {
       nodeId: observable,
       nodeKey: observable,
+      holds: observable,
+      nodeToFocus: observable,
+      runFromKeyboard: action,
+      clearNodeToFocus: action,
+      isHeld: computed,
+      holdOpen: action,
+      finish: action,
+      finishApplied: action,
       draft: observable.ref,
       notice: observable,
       node: computed,
@@ -87,8 +115,14 @@ export class CubeNodeEditorState {
       hasChanges: computed,
       open: action,
       canSwapInputs: computed,
+      canRenameDuplicateColumns: computed,
+      canRenameConcatInput: computed,
+      canRestrictConcatInput: computed,
       apply: action,
       swapInputs: action,
+      renameDuplicateColumns: action,
+      renameConcatInput: action,
+      restrictConcatInput: action,
       close: action,
       cancel: action,
       discard: action,
@@ -124,7 +158,10 @@ export class CubeNodeEditorState {
     );
   }
 
-  /** Opens the panel on a node, closing (and so applying) the one it showed */
+  /**
+   * Opens the editor on a node, finishing (and so applying) the one it showed;
+   * does nothing while that one is held open, or kept open saying why
+   */
   open(nodeId: string): void {
     if (nodeId === this.nodeId) {
       this.notice = undefined;
@@ -134,9 +171,11 @@ export class CubeNodeEditorState {
     if (!node) {
       return;
     }
-    this.close();
     this.notice = undefined;
-    this.bind(node);
+    if (this.finish()) {
+      // the node as the cube has it once the other editor finished
+      this.bind(this.editorState.document.query.getNode(nodeId) ?? node);
+    }
   }
 
   /**
@@ -151,7 +190,8 @@ export class CubeNodeEditorState {
       !edited ||
       node.key !== this.nodeKey ||
       !this.hasChanges ||
-      this.editorState.readOnly
+      this.editorState.readOnly ||
+      this.draft?.applyDisabledReason !== undefined
     ) {
       return;
     }
@@ -190,10 +230,304 @@ export class CubeNodeEditorState {
     this.bind(query.getNode(node.id) ?? node);
   }
 
-  /** Applies the draft, then closes the panel (spec §17.5: edits commit on close) */
+  /**
+   * 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);
+  }
+
+  /**
+   * The query with the draft applied and the node's input schemas, when the
+   * node is the one the panel was opened on and the cube can be changed
+   */
+  private get fixable():
+    | { node: QueryNode; query: Query; inputSchemas: (Schema | undefined)[] }
+    | undefined {
+    const { node } = this;
+    return node && node.key === this.nodeKey && !this.editorState.readOnly
+      ? { node, ...this.queryWithEdits }
+      : undefined;
+  }
+
+  /**
+   * Applies a fix of the query made from the draft applied, as one undo step,
+   * then goes on editing the node
+   */
+  private applyFix(
+    fix: (
+      query: Query,
+      nodeId: string,
+      inputSchemas: (Schema | undefined)[],
+    ) => Query,
+  ): void {
+    const { fixable } = this;
+    if (!fixable) {
+      return;
+    }
+    const { node, query, inputSchemas } = fixable;
+    const fixed = fix(query, node.id, inputSchemas);
+    this.editorState.applyQuery(fixed);
+    this.bind(fixed.getNode(node.id) ?? node);
+  }
+
+  /**
+   * Whether the concat being edited can be fixed by a Rename before its
+   * second input (PLAN §11.5, Q6), and the cube isn't read-only
+   */
+  get canRenameConcatInput(): boolean {
+    const { fixable } = this;
+    return (
+      fixable !== undefined &&
+      canRenameConcatInput(
+        fixable.query,
+        fixable.node.id,
+        fixable.inputSchemas[0],
+        fixable.inputSchemas[1],
+      )
+    );
+  }
+
+  /** Adds the Rename before the concat's second input, as one undo step */
+  renameConcatInput(): void {
+    if (this.canRenameConcatInput) {
+      this.applyFix((query, nodeId, [first, second]) =>
+        renameConcatInput(query, nodeId, first, second),
+      );
+    }
+  }
+
+  /**
+   * Whether the concat being edited can be fixed by a Restrict before its
+   * wider input (PLAN §11.5, Q6), and the cube isn't read-only
+   */
+  get canRestrictConcatInput(): boolean {
+    const { fixable } = this;
+    return (
+      fixable !== undefined &&
+      canRestrictConcatInput(
+        fixable.query,
+        fixable.node.id,
+        fixable.inputSchemas[0],
+        fixable.inputSchemas[1],
+      )
+    );
+  }
+
+  /** Adds the Restrict before the concat's wider input, as one undo step */
+  restrictConcatInput(): void {
+    if (this.canRestrictConcatInput) {
+      this.applyFix((query, nodeId, [first, second]) =>
+        restrictConcatInput(query, nodeId, first, second),
+      );
+    }
+  }
+
+  /**
+   * Applies the draft, then closes the panel (spec §17.5: edits commit on
+   * close). A draft whose Apply waits, e.g. an Extend whose expressions
+   * aren't validated, keeps the panel open and says why, rather than
+   * dropping or storing what can't be applied yet; Cancel drops it.
+   */
   close(): void {
+    if (this.keepOpenWhileWaiting()) {
+      return;
+    }
     this.apply();
     this.reset();
+    this.notice = undefined;
+  }
+
+  /**
+   * Whether a dropdown, picker or dialog opened from the editor is open: then
+   * nothing outside it closes the editor, and the page's shortcuts wait
+   * (spec §17.5)
+   */
+  get isHeld(): boolean {
+    return this.holds > 0;
+  }
+
+  /**
+   * Holds the editor open while something opened from it is open; call the
+   * returned function, once, when that closes
+   */
+  holdOpen(): () => void {
+    this.holds += 1;
+    let released = false;
+    return action(() => {
+      if (!released) {
+        released = true;
+        this.holds -= 1;
+      }
+    });
+  }
+
+  /**
+   * Has `finish` commit the editor's pending input first, e.g. by moving the
+   * focus out of a field that stores its text on blur; returns the function
+   * that removes it. One asked to run first runs before the others: the
+   * editor's blur, so a field's text is stored before what reads it.
+   */
+  addFlusher(
+    flush: () => void,
+    options?: {
+      first?: boolean;
+      /** Whether it has input to commit, e.g. text typed and not applied */
+      isPending?: () => boolean;
+    },
+  ): () => void {
+    const flusher = { flush, isPending: options?.isPending ?? (() => false) };
+    this.flushers = options?.first
+      ? [flusher, ...this.flushers]
+      : [...this.flushers, flusher];
+    return () => {
+      this.flushers = this.flushers.filter((other) => other !== flusher);
+    };
+  }
+
+  /**
+   * Whether the editor holds input a flusher would commit on closing, e.g. a
+   * warehouse typed and not applied; read when asked, not observed
+   */
+  hasPendingInput(): boolean {
+    return this.flushers.some((flusher) => flusher.isPending());
+  }
+
+  /**
+   * Keeps the editor open, saying why, when its draft's Apply waits, e.g. an
+   * Extend whose expressions aren't validated (PLAN §11.7), rather than
+   * dropping or storing what can't be applied yet; says whether it did
+   */
+  private keepOpenWhileWaiting(): boolean {
+    const { nodeId, draft } = this;
+    const waiting = draft?.applyDisabledReason;
+    if (
+      nodeId === undefined ||
+      waiting === undefined ||
+      !this.hasChanges ||
+      this.editorState.readOnly
+    ) {
+      return false;
+    }
+    this.notice = getEditorKeptOpenNotice(nodeId, waiting);
+    return true;
+  }
+
+  /**
+   * Finishes with the editor as anything but Cancel does (PLAN §11.8): commits
+   * its pending input, then closes it, applying the edits as one undo step.
+   * Edits the query can't take close it with a notice instead of vanishing.
+   * Does nothing while something opened from the editor holds it open, and
+   * keeps it open, saying why, while its Apply waits (PLAN §11.7).
+   */
+  private finishWith(): 'held' | 'kept' | 'dropped' | 'closed' {
+    if (this.nodeId === undefined) {
+      return 'closed';
+    }
+    if (this.isHeld) {
+      return 'held';
+    }
+    this.flushers.forEach((flusher) => flusher.flush());
+    if (this.keepOpenWhileWaiting()) {
+      return 'kept';
+    }
+    const { edited } = this;
+    if (
+      edited !== undefined &&
+      this.hasChanges &&
+      !this.editorState.readOnly &&
+      !this.editorState.document.query.canReplace(edited)
+    ) {
+      this.discard(CUBE_EDITOR_CLOSED_REASON.CANNOT_APPLY);
+      return 'dropped';
+    }
+    this.close();
+    return 'closed';
+  }
+
+  /** Finishes with the editor (`finishWith`); says whether it is closed */
+  finish(): boolean {
+    const finished = this.finishWith();
+    return finished === 'dropped' || finished === 'closed';
+  }
+
+  /**
+   * Finishes with the editor (`finishWith`); says whether its edits, if any,
+   * are now in the cube, so what comes next acts on them: false while it is
+   * held or kept open, or when its edits had to be dropped
+   */
+  finishApplied(): boolean {
+    return this.finishWith() === 'closed';
+  }
+
+  /**
+   * Runs what a shortcut does (F9, Ctrl+Z), which may finish the editor: when
+   * it closes the editor while the keyboard was in it, the keyboard goes back
+   * to the node (PLAN §11.8), as on Escape. The canvas takes the request.
+   */
+  runFromKeyboard(run: () => void, focusWasInEditor: boolean): void {
+    const { nodeId } = this;
+    run();
+    if (focusWasInEditor && nodeId !== undefined && this.nodeId === undefined) {
+      this.nodeToFocus = nodeId;
+    }
+  }
+
+  clearNodeToFocus(): void {
+    this.nodeToFocus = undefined;
   }
 
   /** Closes the panel, dropping the draft */
@@ -241,6 +575,10 @@ export class CubeNodeEditorState {
       return;
     }
     if (this.hasChanges) {
+      if (node && this.draft?.follow(node)) {
+        this.nodeKey = node.key;
+        return;
+      }
       this.discard(
         node
           ? CUBE_EDITOR_CLOSED_REASON.NODE_CHANGED

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,
@@ -24,8 +25,11 @@ import type { CubeEditorState } from './CubeEditorState.js';
 
 /**
  * Show Pure: the Pure text of what Execute would run, the capture node's
- * execution lambda with the row limit, as the engine renders it. For display
- * only: the text is never parsed back (PLAN §8.7).
+ * execution lambda, as the engine renders it. It leaves out the row limit
+ * Execute adds (`limit(rowLimit + 1)`, how the grid knows there are more
+ * rows), as Legend Query's own Show Pure does: only a Take or Drop the user
+ * added shows (user, 2026-10-10). For display only: the text is never parsed
+ * back (PLAN §8.7).
  */
 export class CubeShowPureState {
   readonly editorState: CubeEditorState;
@@ -50,11 +54,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 { execution, document, emitter, host } = this.editorState;
+    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 +74,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({ runtime, databaseType }),
       )) as string;
       if (request === this.request) {
         this.text = text;