@finos/legend-cube-builder 0.0.0-stage → 0.0.3

package/src/stores/CubeNodeEditorState.ts

@@ -0,0 +1,324 @@
+/**
+ * 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 {
+  canFixJoinDuplicates,
+  fixJoinDuplicates,
+  type NodeRegistry,
+  type Query,
+  type QueryNode,
+  type Schema,
+} from '@finos/legend-cube';
+import {
+  action,
+  computed,
+  type IReactionDisposer,
+  makeObservable,
+  observable,
+  reaction,
+} from 'mobx';
+import {
+  CUBE_EDITOR_CLOSED_REASON,
+  getEditorClosedNotice,
+} from '../__lib__/LegendCubeLabels.js';
+import type { CubeEditorState } from './CubeEditorState.js';
+import type { CubeNodeDraft } from './editors/CubeNodeDraft.js';
+import { createCubeNodeDraft } from './editors/CubeNodeDraftRegistry.js';
+
+/**
+ * Whether two nodes of the same id save the same: their own fields, as the
+ * spec stores them, and the keys this version doesn't know. A node of a type
+ * the registry doesn't know is the same only as itself.
+ */
+export const isSameNodeContent = (
+  registry: NodeRegistry,
+  a: QueryNode,
+  b: QueryNode,
+): boolean => {
+  if (a === b) {
+    return true;
+  }
+  const definition = registry.get(a.type);
+  return (
+    definition !== undefined &&
+    a.type === b.type &&
+    JSON.stringify([definition.spec.encode(a), a.rest]) ===
+      JSON.stringify([definition.spec.encode(b), b.rest])
+  );
+};
+
+/**
+ * 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 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
+ * Remove, a panel with edits closes without applying them and says so; one
+ * without edits shows the new node, or closes when the node is gone.
+ */
+export class CubeNodeEditorState {
+  readonly editorState: CubeEditorState;
+
+  /** The id of the node the panel shows, while it is open */
+  nodeId: string | undefined;
+  /** The key of the node the draft was made from */
+  private nodeKey: number | undefined;
+  draft: CubeNodeDraft | undefined;
+  /** Why the panel closed by itself, until it opens again or is dismissed */
+  notice: string | undefined;
+
+  private readonly disposeSync: IReactionDisposer;
+
+  constructor(editorState: CubeEditorState) {
+    makeObservable<CubeNodeEditorState, 'nodeKey' | 'sync'>(this, {
+      nodeId: observable,
+      nodeKey: observable,
+      draft: observable.ref,
+      notice: observable,
+      node: computed,
+      edited: computed,
+      hasChanges: computed,
+      open: action,
+      canSwapInputs: computed,
+      canRenameDuplicateColumns: computed,
+      apply: action,
+      swapInputs: action,
+      renameDuplicateColumns: action,
+      close: action,
+      cancel: action,
+      discard: action,
+      dismissNotice: action,
+      sync: action,
+    });
+    this.editorState = editorState;
+    this.disposeSync = reaction(
+      () => this.node,
+      () => this.sync(),
+    );
+  }
+
+  /** The node the panel shows, as the cube has it now */
+  get node(): QueryNode | undefined {
+    return this.nodeId === undefined
+      ? undefined
+      : this.editorState.document.query.getNode(this.nodeId);
+  }
+
+  /** The node Apply would store, built once per edit */
+  get edited(): QueryNode | undefined {
+    return this.draft?.build();
+  }
+
+  /** The draft saves differently from the node it was made from */
+  get hasChanges(): boolean {
+    const { draft, edited } = this;
+    return (
+      draft !== undefined &&
+      edited !== undefined &&
+      !isSameNodeContent(this.editorState.registry, edited, draft.original)
+    );
+  }
+
+  /** Opens the panel on a node, closing (and so applying) the one it showed */
+  open(nodeId: string): void {
+    if (nodeId === this.nodeId) {
+      this.notice = undefined;
+      return;
+    }
+    const node = this.editorState.document.query.getNode(nodeId);
+    if (!node) {
+      return;
+    }
+    this.close();
+    this.notice = undefined;
+    this.bind(node);
+  }
+
+  /**
+   * Stores the draft in place of the node, as one undo step, and goes on
+   * editing the stored node. Does nothing without changes, or while the cube
+   * is read-only.
+   */
+  apply(): void {
+    const { node, edited } = this;
+    if (
+      !node ||
+      !edited ||
+      node.key !== this.nodeKey ||
+      !this.hasChanges ||
+      this.editorState.readOnly
+    ) {
+      return;
+    }
+    const { query } = this.editorState.document;
+    if (query.canReplace(edited)) {
+      this.editorState.applyQuery(query.replace(edited));
+      this.bind(edited);
+    }
+  }
+
+  get canSwapInputs(): boolean {
+    const { node } = this;
+    return (
+      node !== undefined &&
+      !this.editorState.readOnly &&
+      this.editorState.document.query.canSwapInputs(node.id)
+    );
+  }
+
+  /**
+   * Swaps the node's two inputs (a Join's Swap Inputs, spec §17.6), applying
+   * the draft first, as one undo step, then goes on editing the swapped
+   * node, whose settings followed its inputs
+   */
+  swapInputs(): void {
+    const { node, edited } = this;
+    if (!node || !edited || node.key !== this.nodeKey || !this.canSwapInputs) {
+      return;
+    }
+    let { query } = this.editorState.document;
+    if (this.hasChanges && query.canReplace(edited)) {
+      query = query.replace(edited);
+    }
+    query = query.swapInputs(node.id);
+    this.editorState.applyQuery(query);
+    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();
+    this.reset();
+  }
+
+  /** Closes the panel, dropping the draft */
+  cancel(): void {
+    this.reset();
+  }
+
+  /**
+   * Closes the panel without applying the draft, e.g. when another cube is
+   * opened, saying so when that drops edits
+   */
+  discard(reason: CUBE_EDITOR_CLOSED_REASON): void {
+    const { nodeId } = this;
+    if (nodeId !== undefined && this.hasChanges) {
+      this.notice = getEditorClosedNotice(nodeId, reason);
+    }
+    this.reset();
+  }
+
+  dismissNotice(): void {
+    this.notice = undefined;
+  }
+
+  /** Stops following the cube; call when the page closes */
+  dispose(): void {
+    this.disposeSync();
+  }
+
+  private bind(node: QueryNode): void {
+    this.nodeId = node.id;
+    this.nodeKey = node.key;
+    this.draft = createCubeNodeDraft(node, this.editorState);
+  }
+
+  private reset(): void {
+    this.nodeId = undefined;
+    this.nodeKey = undefined;
+    this.draft = undefined;
+  }
+
+  /** Runs whenever the node with the panel's id is another object, or gone */
+  private sync(): void {
+    const { node } = this;
+    if (this.nodeId === undefined || node?.key === this.nodeKey) {
+      return;
+    }
+    if (this.hasChanges) {
+      this.discard(
+        node
+          ? CUBE_EDITOR_CLOSED_REASON.NODE_CHANGED
+          : CUBE_EDITOR_CLOSED_REASON.NODE_REMOVED,
+      );
+    } else if (node) {
+      this.bind(node);
+    } else {
+      this.reset();
+    }
+  }
+}

package/src/stores/CubeShowPureState.ts

@@ -0,0 +1,118 @@
+/**
+ * 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 { needsDatabaseType } from '@finos/legend-cube';
+import type { GeneratorFn } from '@finos/legend-shared';
+import { action, flow, flowResult, makeObservable, observable } from 'mobx';
+import {
+  CubeEngineError,
+  CubeEngineErrorKind,
+} from '../graph-manager/CubeEngine.js';
+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).
+ */
+export class CubeShowPureState {
+  readonly editorState: CubeEditorState;
+
+  isOpen = false;
+  text: string | undefined;
+  /** Why the engine couldn't render the query; shown in the dialog */
+  error: CubeEngineError | undefined;
+  isRendering = false;
+  /** Counts renders, so one that finishes after the dialog closed is dropped */
+  private request = 0;
+
+  constructor(editorState: CubeEditorState) {
+    makeObservable(this, {
+      isOpen: observable,
+      text: observable,
+      error: observable.ref,
+      isRendering: observable,
+      open: flow,
+      close: action,
+    });
+    this.editorState = editorState;
+  }
+
+  /**
+   * 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 { 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;
+    this.isOpen = true;
+    this.text = undefined;
+    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, databaseType }),
+      )) as string;
+      if (request === this.request) {
+        this.text = text;
+      }
+    } catch (error) {
+      if (request === this.request) {
+        this.error =
+          error instanceof CubeEngineError
+            ? error
+            : new CubeEngineError(
+                CubeEngineErrorKind.COMPILE,
+                error instanceof Error ? error.message : String(error),
+              );
+      }
+    } finally {
+      if (request === this.request) {
+        this.isRendering = false;
+      }
+    }
+  }
+
+  close(): void {
+    this.request++;
+    this.isOpen = false;
+    this.isRendering = false;
+    this.text = undefined;
+    this.error = undefined;
+  }
+}