@finos/legend-cube-builder 0.0.4 → 0.0.5

package/src/components/editors/CubeExpressionFilterEditor.tsx

@@ -0,0 +1,193 @@
+/**
+ * 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 { CompressIcon, ExpandIcon } from '@finos/legend-art';
+import type { Schema } from '@finos/legend-cube';
+import { CompilationError, SourceInformation } from '@finos/legend-graph';
+import { CodeEditor } from '@finos/legend-lego/code-editor';
+import { guaranteeType } from '@finos/legend-shared';
+import { flowResult } from 'mobx';
+import { observer } from 'mobx-react-lite';
+import { useState } from 'react';
+import {
+  EXPRESSION_FILTER_EDITOR_NOTES,
+  getExactColumnTypeLabel,
+  READ_ONLY_CUBE_TITLE,
+} from '../../__lib__/LegendCubeLabels.js';
+import {
+  type CubeConditionProblem,
+  CubeExpressionFilterDraft,
+} from '../../stores/editors/CubeExpressionFilterDraft.js';
+import { CubeButton } from '../CubeButton.js';
+import { CubeColumnTypeIcon } from './CubeColumnPicker.js';
+import { columnAccessOf } from './CubeExtendEditor.js';
+import type { CubeNodeEditorProps } from './CubeNodeEditorRegistry.js';
+
+/** The code editor's language: legend-code-editor's `CODE_EDITOR_LANGUAGE.PURE` */
+const PURE = 'pure';
+
+/** The error the code editor marks, from the condition's problem located in its code */
+const markerOf = (
+  problem: CubeConditionProblem | undefined,
+): CompilationError | undefined => {
+  const location = problem?.location;
+  if (!problem || !location) {
+    return undefined;
+  }
+  const error = new CompilationError(problem.message);
+  error.sourceInformation = new SourceInformation(
+    location.sourceId,
+    location.startLine,
+    location.startColumn,
+    location.endLine,
+    location.endColumn,
+  );
+  return error;
+};
+
+/**
+ * What the editor says under the code: its problem, but one Cube refused,
+ * which the panel's problems show; that it is checked, or that it waits
+ */
+const CubeConditionStatus = observer(
+  (props: { draft: CubeExpressionFilterDraft }) => {
+    const { draft } = props;
+    const { problem } = draft;
+    if (problem?.refused) {
+      return null;
+    }
+    if (problem) {
+      return (
+        <div className="text-sm text-[var(--color-status-error)]">
+          <div>{problem.message}</div>
+          {problem.hint && (
+            <div className="text-[var(--color-text-secondary)]">
+              {problem.hint}
+            </div>
+          )}
+        </div>
+      );
+    }
+    if (!draft.isValidated) {
+      return (
+        <div className="text-sm text-[var(--color-text-muted)]">
+          Not validated yet
+        </div>
+      );
+    }
+    return draft.isChecked ? (
+      <div className="text-sm text-[var(--color-text-secondary)]">
+        One Boolean of a row: the rows for which it is true are kept
+      </div>
+    ) : null;
+  },
+);
+
+/**
+ * The Filter by Expression editor (PLAN §11.11): the condition's code in a
+ * code editor, Validate (F10), which the engine does, and the input's
+ * columns, which a click writes at the end of the code.
+ */
+export const CubeExpressionFilterEditor = observer(
+  (props: CubeNodeEditorProps) => {
+    const { inputSchemas, readOnly } = props;
+    const draft = guaranteeType(props.draft, CubeExpressionFilterDraft);
+    const [schema] = inputSchemas as [Schema];
+    const [expanded, setExpanded] = useState(false);
+    const disabled = readOnly || draft.validating;
+    return (
+      <div className="flex flex-col gap-2 text-base">
+        <div className="flex items-center gap-1">
+          <span className="flex-1">Condition</span>
+          <button
+            className="flex h-6 w-6 items-center justify-center text-[var(--color-text-secondary)]"
+            aria-label="Expand the condition"
+            title={expanded ? 'Show fewer lines' : 'Show more lines'}
+            onClick={() => setExpanded(!expanded)}
+          >
+            {expanded ? <CompressIcon /> : <ExpandIcon />}
+          </button>
+        </div>
+        <div
+          aria-label="Condition"
+          className="overflow-hidden rounded-sm border border-[var(--color-border-default)]"
+          style={{ height: expanded ? 240 : 96 }}
+        >
+          <CodeEditor
+            inputValue={draft.code}
+            updateInput={(code) => draft.setCode(code)}
+            language={PURE}
+            isReadOnly={disabled}
+            hideMinimap={true}
+            hideGutter={true}
+            hideActionBar={true}
+            error={markerOf(draft.problem)}
+            extraEditorOptions={{
+              lineNumbers: 'off',
+              wordWrap: 'on',
+              scrollBeyondLastLine: false,
+            }}
+          />
+        </div>
+        <CubeConditionStatus draft={draft} />
+        <div className="flex items-center gap-2">
+          <CubeButton
+            primary={!draft.isValidated}
+            title={
+              readOnly
+                ? READ_ONLY_CUBE_TITLE
+                : "Check the condition with the engine, and plan it for this cube's database (F10)"
+            }
+            disabled={disabled}
+            onClick={() => {
+              flowResult(draft.validate()).catch(
+                props.editorState.host.applicationStore.alertUnhandledError,
+              );
+            }}
+          >
+            {draft.validating ? 'Validating…' : 'Validate'}
+          </CubeButton>
+        </div>
+        <span>Input columns</span>
+        <ul aria-label="Input columns" className="flex flex-wrap gap-1">
+          {schema.columns.map((column) => (
+            <li key={column.name}>
+              <button
+                className="flex items-center gap-1 rounded-sm border border-[var(--color-border-subtle)] px-1 text-sm hover:bg-[var(--color-bg-hover)] disabled:text-[var(--color-text-disabled)]"
+                title={`Write ${columnAccessOf(column.name)} at the end of the condition (${getExactColumnTypeLabel(column)})`}
+                disabled={disabled}
+                onClick={() => {
+                  const separator = /\s$/u.test(draft.code) ? '' : ' ';
+                  draft.setCode(
+                    `${draft.code}${separator}${columnAccessOf(column.name)}`,
+                  );
+                }}
+              >
+                <CubeColumnTypeIcon type={column.type} />
+                {column.name}
+              </button>
+            </li>
+          ))}
+        </ul>
+        <ul className="flex list-disc flex-col gap-1 pl-4 text-sm text-[var(--color-text-secondary)]">
+          {EXPRESSION_FILTER_EDITOR_NOTES.map((note) => (
+            <li key={note}>{note}</li>
+          ))}
+        </ul>
+      </div>
+    );
+  },
+);

package/src/components/editors/CubeExtendEditor.tsx

@@ -31,7 +31,7 @@ import { useState } from 'react';
 import {
   COLUMN_NAME_RULES_HINT,
   EXTEND_EDITOR_NOTES,
-  getColumnTypeLabel,
+  getExactColumnTypeLabel,
   READ_ONLY_CUBE_TITLE,
 } from '../../__lib__/LegendCubeLabels.js';
 import {
@@ -46,7 +46,7 @@ import type { CubeNodeEditorProps } from './CubeNodeEditorRegistry.js';
 const PURE = 'pure';
 
 /** How an expression reads a column: `$x.NAME`, or `$x.'a name'` for one that isn't an identifier */
-const columnAccessOf = (name: string): string =>
+export const columnAccessOf = (name: string): string =>
   /^[A-Za-z_][A-Za-z0-9_]*$/u.test(name)
     ? `$x.${name}`
     : `$x.'${name.replace(/\\/gu, '\\\\').replace(/'/gu, "\\'")}'`;
@@ -243,7 +243,7 @@ export const CubeExtendEditor = observer((props: CubeNodeEditorProps) => {
           <li key={column.name}>
             <button
               className="flex items-center gap-1 rounded-sm border border-[var(--color-border-subtle)] px-1 text-sm hover:bg-[var(--color-bg-hover)] disabled:text-[var(--color-text-disabled)]"
-              title={`Write ${columnAccessOf(column.name)} at the end of the expression last used (${getColumnTypeLabel(column)})`}
+              title={`Write ${columnAccessOf(column.name)} at the end of the expression last used (${getExactColumnTypeLabel(column)})`}
               disabled={readOnly || draft.validating || !target}
               onClick={() => {
                 if (target) {

package/src/components/editors/CubeFilterEditor.tsx

@@ -21,6 +21,7 @@ import {
   CompositeFilterOperator,
   FILTER_OPERATOR_DESCRIPTIONS,
   type FilterRule,
+  findPatternWildcardOperator,
   getAvailableOperators,
   getFilterValueShape,
   isDateOrTimestampType,
@@ -31,8 +32,10 @@ import {
   NotFilter,
   type Schema,
 } from '@finos/legend-cube';
-import { guaranteeType } from '@finos/legend-shared';
+import { guaranteeType, noop } from '@finos/legend-shared';
+import { flowResult } from 'mobx';
 import { observer } from 'mobx-react-lite';
+import { useEffect } from 'react';
 import {
   DATE_OR_TIMESTAMP_WARNING,
   FILTER_FLOAT_COMPARISON_HINT,
@@ -297,8 +300,17 @@ const CubeFilterGroup = observer(
  * kept, marked, to be fixed. Blank conditions are not stored.
  */
 export const CubeFilterEditor = observer((props: CubeNodeEditorProps) => {
+  const { editorState } = props;
   const draft = guaranteeType(props.draft, CubeFilterDraft);
   const [schema] = props.inputSchemas as [Schema];
+  // a pattern given % or _ is refused on some databases, which the model's
+  // outline tells (PLAN §11.11)
+  const givesWildcard = findPatternWildcardOperator(draft.tree) !== undefined;
+  useEffect(() => {
+    if (givesWildcard) {
+      flowResult(editorState.loadModelOutline()).catch(noop());
+    }
+  }, [editorState, givesWildcard]);
   return (
     <div className="flex flex-col gap-2">
       <CubeFilterGroup

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/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,11 @@ import {
   IngestDatasetSource,
   Distinct,
   Drop,
+  ExpressionFilter,
+  Pivot,
   Extend,
   Filter,
+  FunctionSource,
   Group,
   Join,
   Limit,
@@ -31,6 +34,7 @@ import {
   Rename,
   Restrict,
   type Schema,
+  ServiceSource,
   Slice,
   Sort,
 } from '@finos/legend-cube';
@@ -38,8 +42,12 @@ 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 { 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 +91,15 @@ 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],
   [Restrict.TYPE, CubeRestrictEditor],
   [Rename.TYPE, CubeRenameEditor],
   [Distinct.TYPE, CubeDistinctEditor],