@finos/legend-cube-builder 0.0.4 → 0.0.6

package/src/components/editors/CubeFunctionSourceEditor.tsx

@@ -0,0 +1,140 @@
+/**
+ * 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 {
+  FunctionSource,
+  getFunctionParameterValueError,
+} from '@finos/legend-cube';
+import { PanelLoadingIndicator } from '@finos/legend-art';
+import { guaranteeType } from '@finos/legend-shared';
+import { flowResult } from 'mobx';
+import { observer } from 'mobx-react-lite';
+import { useId } from 'react';
+import { CUBE_PENDING_LABEL } from '../../__lib__/LegendCubeLabels.js';
+import { CubeFunctionDraft } from '../../stores/editors/CubeFunctionDraft.js';
+import { CubeButton } from '../CubeButton.js';
+import { CubeSchemaColumnsTable } from '../CubeSchemaColumnsTable.js';
+import type { CubeNodeEditorProps } from './CubeNodeEditorRegistry.js';
+
+const INPUT_CLASS =
+  'h-7 min-w-0 flex-1 rounded-sm border border-[var(--color-border-default)] bg-[var(--color-bg-input)] px-1 text-base text-[var(--color-text-primary)] disabled:text-[var(--color-text-secondary)]';
+
+const CubeFunctionValueInput = observer(
+  (props: { draft: CubeFunctionDraft; index: number; readOnly: boolean }) => {
+    const { draft, index, readOnly } = props;
+    const id = useId();
+    const parameter = draft.original.parameters[index];
+    if (!parameter) {
+      return null;
+    }
+    const error = getFunctionParameterValueError(
+      parameter,
+      draft.values[index],
+    );
+    return (
+      <div className="flex flex-col gap-0.5">
+        <div className="flex items-center gap-2">
+          <label
+            className="w-32 shrink-0 truncate text-base"
+            htmlFor={id}
+            title={parameter.name}
+          >
+            {parameter.name}
+          </label>
+          <input
+            id={id}
+            className={INPUT_CLASS}
+            placeholder={`${parameter.type.displayName}${parameter.optional ? ', optional' : ''}`}
+            disabled={readOnly}
+            aria-invalid={error !== undefined}
+            value={draft.valueTexts[index] ?? ''}
+            onChange={(event) => draft.setValueText(index, event.target.value)}
+          />
+        </div>
+        {error !== undefined && (
+          <span className="pl-[8.5rem] text-sm text-[var(--color-status-error)]">
+            {error}
+          </span>
+        )}
+      </div>
+    );
+  },
+);
+
+/**
+ * A function source (PLAN §6.5): the function, the runtime the cube runs
+ * on, a value for each parameter, which Apply stores, its columns, and
+ * Refresh, which types it again
+ */
+export const CubeFunctionSourceEditor = observer(
+  (props: CubeNodeEditorProps) => {
+    const { editorState, readOnly } = props;
+    const draft = guaranteeType(props.draft, CubeFunctionDraft);
+    const source = guaranteeType(draft.original, FunctionSource);
+    const { resolution } = source;
+    const refreshing = editorState.isPendingSource(source);
+    return (
+      <div className="relative flex flex-col gap-2">
+        <dl className="grid grid-cols-[max-content_1fr] gap-x-3 gap-y-1 text-base">
+          <dt className="text-[var(--color-text-secondary)]">Function</dt>
+          <dd className="min-w-0 break-all" title={source.signature}>
+            {source.function}
+          </dd>
+          <dt className="text-[var(--color-text-secondary)]">Runtime</dt>
+          <dd className="min-w-0 break-all">
+            {editorState.document.context?.runtime ?? ''}
+          </dd>
+        </dl>
+        {source.parameters.map((parameter, index) => (
+          <CubeFunctionValueInput
+            key={parameter.name}
+            draft={draft}
+            index={index}
+            readOnly={readOnly}
+          />
+        ))}
+        <div className="flex items-center gap-2">
+          <CubeButton
+            title="Read the function's columns again"
+            disabled={refreshing}
+            onClick={() => {
+              flowResult(editorState.refreshSource(source.id)).catch(
+                editorState.host.applicationStore.alertUnhandledError,
+              );
+            }}
+          >
+            Refresh
+          </CubeButton>
+          {refreshing && (
+            <span className="text-base text-[var(--color-text-secondary)]">
+              {CUBE_PENDING_LABEL.REFRESHING_SOURCE}
+            </span>
+          )}
+        </div>
+        <PanelLoadingIndicator isLoading={refreshing} />
+        {resolution.kind === 'resolved' ? (
+          <CubeSchemaColumnsTable schema={resolution.schema} />
+        ) : (
+          <div className="whitespace-pre-wrap text-base text-[var(--color-text-secondary)]">
+            {resolution.kind === 'failed'
+              ? resolution.message
+              : 'The function has not been typed yet.'}
+          </div>
+        )}
+      </div>
+    );
+  },
+);

package/src/components/editors/CubeJoinEditor.tsx

@@ -15,10 +15,12 @@
  */
 
 import {
+  foldColumnName,
   getDuplicateJoinColumns,
   isJoinType,
   JOIN_TYPE_LABELS,
   JOIN_TYPES,
+  type JoinDuplicateFix,
   planJoinDuplicateFix,
   type Schema,
 } from '@finos/legend-cube';
@@ -32,6 +34,25 @@ import { CubeButton } from '../CubeButton.js';
 import { CubeJoinKeyRows } from './CubeJoinKeyRows.js';
 import type { CubeNodeEditorProps } from './CubeNodeEditorRegistry.js';
 
+/**
+ * What the autofix does to a shared column, as the Join editor lists it
+ * (PLAN §11.14): its Left rename, or that it keeps its name (a key both sides
+ * give as one column), then each Right column of its name in any case and
+ * its rename, the Right's name shown when it differs (`id → id_2`)
+ */
+const describeFix = (fix: JoinDuplicateFix, name: string): string => {
+  const left = fix.left.find(({ from }) => from === name);
+  const rights = fix.right.filter(
+    ({ from }) => foldColumnName(from) === foldColumnName(name),
+  );
+  return [
+    left ? `${name} → ${left.to} (Left)` : `${name} kept (Left)`,
+    ...rights.map(({ from, to }) =>
+      from === name ? `${to} (Right)` : `${from} → ${to} (Right)`,
+    ),
+  ].join(', ');
+};
+
 /**
  * The Join editor (spec §17.6): the join type, pairs of key columns
  * (`CubeJoinKeyRows`), and Swap Inputs.
@@ -99,11 +120,9 @@ export const CubeJoinEditor = observer((props: CubeNodeEditorProps) => {
             both:
           </div>
           <ul aria-label="Columns in both inputs">
-            {duplicates.map((name, index) => (
+            {duplicates.map((name) => (
               <li key={name} className="break-all font-mono">
-                {fix
-                  ? `${name} → ${fix.left[index]?.to} (Left), ${fix.right[index]?.to} (Right)`
-                  : name}
+                {fix ? describeFix(fix, name) : name}
               </li>
             ))}
           </ul>

package/src/components/editors/CubeJsonFieldsTree.tsx

@@ -0,0 +1,316 @@
+/**
+ * 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 { CaretDownIcon, CaretRightIcon, clsx } from '@finos/legend-art';
+import { type SchemaColumn, TypeFamily } from '@finos/legend-cube';
+import { flowResult } from 'mobx';
+import { observer } from 'mobx-react-lite';
+import {
+  CUBE_JSON_FIELDS_TITLE,
+  getCubeJsonFieldsStatus,
+} from '../../__lib__/LegendCubeLabels.js';
+import type { CubeJsonFieldsState } from '../../stores/variant/CubeJsonFieldsState.js';
+import {
+  type CubeJsonField,
+  getCubeJsonFieldDefault,
+  getCubeJsonOfferExpression,
+} from '../../stores/variant/CubeJsonOffers.js';
+import { CubeButton } from '../CubeButton.js';
+
+/** Whether a column holds JSON, whose fields an expression editor can open */
+export const isCubeJsonColumn = (column: SchemaColumn): boolean =>
+  column.type.family === TypeFamily.VARIANT;
+
+/**
+ * The caret beside a Variant column's chip, which opens or closes its fields;
+ * greyed, with the reason, on a database without JSON functions
+ */
+export const CubeJsonFieldsToggle = observer(
+  (props: {
+    fields: CubeJsonFieldsState;
+    column: SchemaColumn;
+    disabled: boolean;
+  }) => {
+    const { fields, column, disabled } = props;
+    const open = fields.isOpen(column.name);
+    const problem = fields.databaseProblem;
+    return (
+      <button
+        type="button"
+        className={clsx(
+          'flex h-full items-center rounded-sm border px-0.5 disabled:text-[var(--color-text-disabled)]',
+          open
+            ? 'border-[var(--color-accent)] text-[var(--color-accent)]'
+            : 'border-[var(--color-border-subtle)] hover:bg-[var(--color-bg-hover)]',
+        )}
+        aria-label={`Fields of ${column.name}`}
+        aria-expanded={open}
+        title={problem ?? (open ? undefined : CUBE_JSON_FIELDS_TITLE.OPEN)}
+        disabled={disabled || problem !== undefined}
+        onClick={() => {
+          // a failed read shows its message under the chips
+          flowResult(fields.toggle(column)).catch(() => undefined);
+        }}
+      >
+        <span className="font-mono text-xs">{'{}'}</span>
+        {open ? <CaretDownIcon /> : <CaretRightIcon />}
+      </button>
+    );
+  },
+);
+
+/** A field of the tree: its key, kind and share, what a click writes, its other forms, then its fields */
+const CubeJsonFieldsRow = observer(
+  (props: {
+    fields: CubeJsonFieldsState;
+    column: string;
+    field: CubeJsonField;
+    depth: number;
+    disabled: boolean;
+    onInsert: (expression: string) => void;
+    onAddColumn: ((name: string, code: string) => void) | undefined;
+  }) => {
+    const { fields, column, field, depth, disabled, onInsert, onAddColumn } =
+      props;
+    const label = [column, ...field.path].join('.');
+    const share = Math.round(field.presence * 100);
+    const folded = fields.isFolded(field.path);
+    const byDefault = getCubeJsonFieldDefault(column, field);
+    const defaultKey = field.offers.find(
+      ({ key }) => key === 'value' || key === 'json',
+    )?.key;
+    const forms = field.offers.filter((offer) => offer.key !== defaultKey);
+    const formsShown = fields.areFormsShown(field.path);
+    return (
+      <li>
+        <div
+          className="flex items-center gap-1 py-0.5 pr-1"
+          style={{ paddingLeft: `${4 + depth * 14}px` }}
+        >
+          {field.children.length ? (
+            <button
+              type="button"
+              className="flex w-4 shrink-0 items-center justify-center text-[var(--color-text-secondary)]"
+              aria-label={`${folded ? 'Unfold' : 'Fold'} ${label}`}
+              onClick={() => fields.toggleFolded(field.path)}
+            >
+              {folded ? <CaretRightIcon /> : <CaretDownIcon />}
+            </button>
+          ) : (
+            <span className="w-4 shrink-0" />
+          )}
+          <button
+            type="button"
+            className="flex min-w-0 flex-1 items-baseline gap-2 rounded-sm px-1 text-left enabled:hover:bg-[var(--color-bg-hover)] disabled:text-[var(--color-text-disabled)]"
+            aria-label={`Write ${label}`}
+            title={`Write ${byDefault.expression}`}
+            disabled={disabled}
+            onClick={() => onInsert(byDefault.expression)}
+          >
+            <span className="break-all font-mono text-sm">
+              {field.path.at(-1) ?? column}
+            </span>
+            <span className="shrink-0 text-xs text-[var(--color-text-secondary)]">
+              {field.description}
+            </span>
+            {share < 100 && (
+              <span className="ml-auto shrink-0 text-xs text-[var(--color-text-muted)]">
+                {share}%
+              </span>
+            )}
+          </button>
+          {onAddColumn && byDefault.column && (
+            <button
+              type="button"
+              className="shrink-0 rounded-sm border border-[var(--color-border-subtle)] px-1 text-sm enabled:hover:bg-[var(--color-bg-hover)] disabled:text-[var(--color-text-disabled)]"
+              aria-label={`Add ${label} as a column`}
+              title={`A new column ${byDefault.column.name}: ${byDefault.column.code}`}
+              disabled={disabled}
+              onClick={() => {
+                if (byDefault.column) {
+                  onAddColumn(byDefault.column.name, byDefault.column.code);
+                }
+              }}
+            >
+              + column
+            </button>
+          )}
+          {forms.length > 0 && (
+            <button
+              type="button"
+              className={clsx(
+                'shrink-0 rounded-sm border px-1 text-sm enabled:hover:bg-[var(--color-bg-hover)]',
+                formsShown
+                  ? 'border-[var(--color-accent)]'
+                  : 'border-[var(--color-border-subtle)]',
+              )}
+              aria-label={`Other forms of ${label}`}
+              aria-expanded={formsShown}
+              title={CUBE_JSON_FIELDS_TITLE.FORMS}
+              onClick={() => fields.toggleForms(field.path)}
+            >
+              ···
+            </button>
+          )}
+        </div>
+        {formsShown && (
+          <ul
+            aria-label={`Forms of ${label}`}
+            className="my-0.5 rounded-sm border border-[var(--color-border-subtle)]"
+            style={{ marginLeft: `${22 + depth * 14}px` }}
+          >
+            {forms.map((offer) => {
+              const expression = getCubeJsonOfferExpression(offer);
+              return (
+                <li key={offer.key}>
+                  <button
+                    type="button"
+                    className="flex w-full items-baseline gap-2 px-2 py-0.5 text-left text-sm enabled:hover:bg-[var(--color-bg-hover)] disabled:text-[var(--color-text-disabled)]"
+                    title={
+                      expression === undefined
+                        ? CUBE_JSON_FIELDS_TITLE.EXPLODE
+                        : `Write ${expression}`
+                    }
+                    disabled={disabled || expression === undefined}
+                    onClick={() => {
+                      if (expression !== undefined) {
+                        onInsert(expression);
+                      }
+                    }}
+                  >
+                    {offer.label}
+                    <span className="text-xs text-[var(--color-text-muted)]">
+                      {offer.explode ? 'Explode Array' : offer.type}
+                    </span>
+                  </button>
+                </li>
+              );
+            })}
+          </ul>
+        )}
+        {!folded && field.children.length > 0 && (
+          <ul>
+            {field.children.map((child) => (
+              <CubeJsonFieldsRow
+                key={JSON.stringify(child.path)}
+                {...props}
+                field={child}
+                depth={depth + 1}
+              />
+            ))}
+          </ul>
+        )}
+      </li>
+    );
+  },
+);
+
+/**
+ * A Variant input column's fields in an expression editor (PLAN §11.20, V.9),
+ * under the input columns while its caret is open: what was read, a search,
+ * and the field tree. A field clicked writes its expression where the
+ * editor's chips write; "+ column", where the editor has rows, adds one; its
+ * other forms write theirs, one row per element being a step of its own.
+ */
+export const CubeJsonFieldsTree = observer(
+  (props: {
+    fields: CubeJsonFieldsState;
+    disabled: boolean;
+    onInsert: (expression: string) => void;
+    onAddColumn?: ((name: string, code: string) => void) | undefined;
+  }) => {
+    const { fields, disabled, onInsert, onAddColumn } = props;
+    const { column } = fields;
+    if (!column) {
+      return null;
+    }
+    const sample =
+      fields.sample?.column === column.name ? fields.sample.sample : undefined;
+    const shown = fields.shownFields;
+    return (
+      <div
+        aria-label={`Fields of ${column.name}, read`}
+        className="flex flex-col gap-1 rounded-sm border border-[var(--color-accent)] p-1"
+      >
+        <div className="flex items-center gap-2 text-sm text-[var(--color-text-secondary)]">
+          <span role="status" className="min-w-0 flex-1">
+            {fields.isReading
+              ? `Reading ${column.name}…`
+              : sample
+                ? getCubeJsonFieldsStatus(sample)
+                : ''}
+          </span>
+          {fields.isReading ? (
+            <CubeButton onClick={() => fields.stop()}>Stop</CubeButton>
+          ) : (
+            sample && (
+              <CubeButton
+                title={
+                  sample.complete
+                    ? CUBE_JSON_FIELDS_TITLE.READ_AGAIN
+                    : CUBE_JSON_FIELDS_TITLE.EVERY_ROW
+                }
+                onClick={() => {
+                  flowResult(fields.read(!sample.complete)).catch(
+                    () => undefined,
+                  );
+                }}
+              >
+                {sample.complete ? 'Read again' : 'Read every row'}
+              </CubeButton>
+            )
+          )}
+        </div>
+        {fields.error && (
+          <div
+            role="alert"
+            className="break-words text-sm text-[var(--color-status-error)]"
+          >
+            {fields.error}
+          </div>
+        )}
+        {fields.fields && (
+          <>
+            <input
+              className="h-6 rounded-sm border border-[var(--color-border-default)] bg-[var(--color-bg-input)] px-1 text-sm"
+              placeholder="Find a field"
+              aria-label="Find a field"
+              value={fields.search}
+              onChange={(event) => fields.setSearch(event.target.value)}
+            />
+            {shown ? (
+              <ul aria-label={`Fields of ${column.name}`}>
+                <CubeJsonFieldsRow
+                  fields={fields}
+                  column={column.name}
+                  field={shown}
+                  depth={0}
+                  disabled={disabled}
+                  onInsert={onInsert}
+                  onAddColumn={onAddColumn}
+                />
+              </ul>
+            ) : (
+              <div className="px-1 text-sm text-[var(--color-text-muted)]">
+                No field matches.
+              </div>
+            )}
+          </>
+        )}
+      </div>
+    );
+  },
+);

package/src/components/editors/CubeNodeEditorPanel.tsx

@@ -27,9 +27,12 @@ import { observer } from 'mobx-react-lite';
 import { useEffect, useId, useRef } from 'react';
 import {
   CUBE_NODE_HELP_TEXT,
+  RUN_THIS_STEP_LABEL,
+  RUNNING_NODE_LABEL,
   SELECT_NODE_TOOLTIP,
 } from '../../__lib__/LegendCubeHelpText.js';
 import {
+  getCubeNodeBadge,
   READ_ONLY_CUBE_TITLE,
   toEditorTitle,
 } from '../../__lib__/LegendCubeLabels.js';
@@ -48,7 +51,8 @@ const validateEdited = (
 ): string[] => {
   const errors: string[] = [];
   node.validate(inputSchemas, errors);
-  // waiting for the engine to type an Extend is no problem (PLAN §11.7)
+  // waiting for the engine to type an Extend, or check a filter's condition,
+  // is no problem (PLAN §11.7, §11.11)
   return [...new Set(errors)].filter((error) => !isTypingError(error));
 };
 
@@ -116,9 +120,15 @@ export const CubeNodeEditorPanel = observer(
     const isEditable = CUBE_NODE_DRAFT_FACTORIES.has(node.type);
     // a draft that waits, e.g. on a Validate, says why in place of its problems
     const waiting = draft.applyDisabledReason;
+    // the node's own, then those of the database it runs on (PLAN §11.11)
     const problems =
       isEditable && !inputProblems.length && waiting === undefined
-        ? validateEdited(edited, inputSchemas)
+        ? [
+            ...new Set([
+              ...validateEdited(edited, inputSchemas),
+              ...editorState.getNodeDatabaseProblems(query, edited),
+            ]),
+          ]
         : [];
     const warnings = editorState.getNodeWarnings(node);
     return (
@@ -143,9 +153,9 @@ export const CubeNodeEditorPanel = observer(
           <span className="shrink-0 text-base text-[var(--color-text-muted)]">
             {node.id}
           </span>
-          {definition?.beta && (
+          {definition && getCubeNodeBadge(definition) && (
             <span className="shrink-0 rounded-sm bg-[var(--color-accent)] px-1 text-xs font-medium text-[var(--color-text-on-accent)]">
-              BETA
+              {getCubeNodeBadge(definition)}
             </span>
           )}
           <span
@@ -162,10 +172,10 @@ export const CubeNodeEditorPanel = observer(
           <span className="flex-1" />
           {isCapture ? (
             <span
-              className="shrink-0 text-base text-[var(--color-text-secondary)]"
-              title={SELECT_NODE_TOOLTIP}
+              className="shrink-0 rounded-sm bg-[var(--color-accent)] px-1 text-sm font-medium text-[var(--color-text-on-accent)]"
+              title="This is the step that runs: Execute shows its rows"
             >
-              (Selected)
+              {`▶ ${RUNNING_NODE_LABEL}`}
             </span>
           ) : (
             <button
@@ -173,7 +183,7 @@ export const CubeNodeEditorPanel = observer(
               title={SELECT_NODE_TOOLTIP}
               onClick={() => editorState.select(node.id)}
             >
-              Select
+              {RUN_THIS_STEP_LABEL}
             </button>
           )}
           <button
@@ -259,14 +269,16 @@ export const CubeNodeEditorPanel = observer(
                 readOnly
                   ? READ_ONLY_CUBE_TITLE
                   : (draft.applyDisabledReason ??
-                    'Store the changes, as one step to undo')
+                    'Store the changes as one step to undo, and close')
               }
               disabled={
                 readOnly ||
                 !nodeEditor.hasChanges ||
                 draft.applyDisabledReason !== undefined
               }
-              onClick={() => nodeEditor.apply()}
+              // Apply closes, as the other ways out but Cancel do (UX
+              // audit B4, user, 2026-10-11)
+              onClick={() => closing(() => nodeEditor.finish())}
             >
               Apply
             </CubeButton>

package/src/components/editors/CubeNodeEditorPopper.tsx

@@ -37,7 +37,11 @@ import { useCubeNodeEditorDismiss } from './useCubeNodeEditorDismiss.js';
  */
 export const CUBE_NODE_EDITOR_WIDTH = 432;
 
-/** Above the canvas and the grid, below MUI's dialogs (1300), so a dialog opened from the editor covers it */
+/**
+ * Above the canvas and the grid, below MUI's dialogs (1300), so a dialog
+ * opened from the editor covers it; inside the dialog that hosts the page,
+ * if one does, so the page's own dialog doesn't
+ */
 export const CUBE_NODE_EDITOR_Z_INDEX = 1250;
 
 /** The gap between the node and its editor, and between the editor and the window's edges */
@@ -157,6 +161,10 @@ export const CubeNodeEditorPopper = observer(
         role="presentation"
         popperRef={popperRef}
         anchorEl={anchor}
+        // a page hosted in a dialog, as Studio hosts Cube, keeps the editor
+        // in the dialog's layer, above the page: on the body, under the
+        // dialogs' z-index, the dialog would hide it
+        container={canvas.closest<HTMLElement>('.MuiDialog-root')}
         placement="bottom"
         modifiers={MODIFIERS}
         style={{

package/src/components/editors/CubeNodeEditorRegistry.ts

@@ -21,8 +21,12 @@ import {
   IngestDatasetSource,
   Distinct,
   Drop,
+  ExpressionFilter,
+  Pivot,
+  Explode,
   Extend,
   Filter,
+  FunctionSource,
   Group,
   Join,
   Limit,
@@ -31,6 +35,7 @@ import {
   Rename,
   Restrict,
   type Schema,
+  ServiceSource,
   Slice,
   Sort,
 } from '@finos/legend-cube';
@@ -38,8 +43,13 @@ import type { CubeEditorState } from '../../stores/CubeEditorState.js';
 import type { CubeNodeDraft } from '../../stores/editors/CubeNodeDraft.js';
 import { CubeConcatEditor } from './CubeConcatEditor.js';
 import { CubeDataProductSourceEditor } from './CubeDataProductSourceEditor.js';
+import { CubeExplodeEditor } from './CubeExplodeEditor.js';
+import { CubeExpressionFilterEditor } from './CubeExpressionFilterEditor.js';
+import { CubePivotEditor } from './CubePivotEditor.js';
 import { CubeDifferenceEditor } from './CubeDifferenceEditor.js';
 import { CubeIngestSourceEditor } from './CubeIngestSourceEditor.js';
+import { CubeServiceSourceEditor } from './CubeServiceSourceEditor.js';
+import { CubeFunctionSourceEditor } from './CubeFunctionSourceEditor.js';
 import { CubeDistinctEditor } from './CubeDistinctEditor.js';
 import { CubeExtendEditor } from './CubeExtendEditor.js';
 import { CubeFilterEditor } from './CubeFilterEditor.js';
@@ -83,11 +93,16 @@ export const CUBE_NODE_EDITORS: ReadonlyMap<
   React.FC<CubeNodeEditorProps>
 > = new Map<string, React.FC<CubeNodeEditorProps>>([
   [RelationalTableSource.TYPE, CubeSourceEditor],
+  [FunctionSource.TYPE, CubeFunctionSourceEditor],
   [DataProductAccessPointSource.TYPE, CubeDataProductSourceEditor],
   [IngestDatasetSource.TYPE, CubeIngestSourceEditor],
+  [ServiceSource.TYPE, CubeServiceSourceEditor],
   [Sort.TYPE, CubeSortEditor],
   [Group.TYPE, CubeGroupEditor],
   [Filter.TYPE, CubeFilterEditor],
+  [ExpressionFilter.TYPE, CubeExpressionFilterEditor],
+  [Pivot.TYPE, CubePivotEditor],
+  [Explode.TYPE, CubeExplodeEditor],
   [Restrict.TYPE, CubeRestrictEditor],
   [Rename.TYPE, CubeRenameEditor],
   [Distinct.TYPE, CubeDistinctEditor],