@finos/legend-cube-builder 0.0.2 → 0.0.3

package/src/__test-utils__/CubeEngineTestSupport.ts

@@ -135,3 +135,38 @@ export const CUBE_ENGINE_TEST__execute = async (
     text: async () => response.data,
   };
 };
+
+/**
+ * Generates the execution plan of a query, never running it, and gives the
+ * SQL of its nodes, outermost first; a body given as text (with lossless
+ * numbers) is sent as it is
+ */
+export const CUBE_ENGINE_TEST__generatePlanSql = async (
+  input: object | string,
+): Promise<string[]> => {
+  const { data } = await axios.post<unknown, AxiosResponse<string>>(
+    `${PURE_API}/execution/generatePlan`,
+    input,
+    {
+      headers: JSON_HEADERS,
+      responseType: 'text',
+      transformResponse: (text: string) => text,
+    },
+  );
+  const sql: string[] = [];
+  const visit = (node: unknown): void => {
+    if (Array.isArray(node)) {
+      node.forEach(visit);
+    } else if (node && typeof node === 'object') {
+      Object.entries(node).forEach(([key, value]) => {
+        if (key === 'sqlQuery' && typeof value === 'string') {
+          sql.push(value);
+        } else {
+          visit(value);
+        }
+      });
+    }
+  };
+  visit(parseLosslessJSON(data));
+  return sql;
+};

package/src/__test-utils__/CubeOperationsTestUtils.ts

@@ -0,0 +1,177 @@
+/**
+ * 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 { expect } from '@jest/globals';
+import {
+  buildSchemasAndValidity,
+  Connection,
+  createNodeRegistry,
+  Query,
+  type QueryNode,
+  QueryEmitter,
+  RelationalTableSource,
+  Schema,
+} from '@finos/legend-cube';
+import type {
+  CubeEngine,
+  CubeResult,
+  CubeResultValue,
+} from '../graph-manager/CubeEngine.js';
+import {
+  CUBE_NORTHWIND_DATABASE,
+  CUBE_NORTHWIND_MODEL,
+  CUBE_NORTHWIND_RUNTIME,
+} from '../stores/fixtures/CubeNorthwindModel.js';
+
+// Helpers for engine tests of operations on the Cube Northwind fixture,
+// through the engine port only (no V1 classes), so any CubeEngine works
+
+/** A table of the Cube Northwind model, not resolved yet */
+export const TEST__northwindTable = (
+  id: string,
+  table: string,
+  schema = 'NORTHWIND',
+): RelationalTableSource =>
+  new RelationalTableSource(id, {
+    database: CUBE_NORTHWIND_DATABASE,
+    schema,
+    table,
+  });
+
+/** The sources, resolved through the engine as the editor resolves them */
+export const TEST__resolveSources = async (
+  engine: CubeEngine,
+  sources: readonly RelationalTableSource[],
+): Promise<RelationalTableSource[]> => {
+  const typed = await engine.resolveSchemas(
+    CUBE_NORTHWIND_MODEL,
+    new Map(
+      sources.map((source) => [
+        source.id,
+        [source.database, source.schema, source.table] as const,
+      ]),
+    ),
+  );
+  return sources.map((source) => {
+    const schema = typed.get(source.id);
+    if (!(schema instanceof Schema)) {
+      throw schema ?? new Error(`No schema for ${source.id}`);
+    }
+    return source.withResolution({ kind: 'resolved', schema });
+  });
+};
+
+/** A chain of nodes, each feeding the next on its first port, captured at the last */
+export const TEST__chainOf = (nodes: readonly QueryNode[]): Query =>
+  new Query(
+    nodes,
+    nodes
+      .slice(1)
+      .map(
+        (node, index) =>
+          new Connection(
+            (nodes[index] as QueryNode).id,
+            node.id,
+            node.ports[0] as string,
+          ),
+      ),
+    nodes.at(-1)?.id,
+  );
+
+/** Every node of the query is valid */
+export const TEST__expectValidQuery = (query: Query): void => {
+  const { validity } = buildSchemasAndValidity(
+    query,
+    createNodeRegistry().queryRules,
+  );
+  expect([...validity].filter(([, errors]) => errors.length)).toEqual([]);
+};
+
+/**
+ * Runs the query up to its capture node, with this row limit; with a database
+ * type, written as for that database (on the fixture's H2 all the same, so a
+ * workaround's rows can be checked)
+ */
+export const TEST__runQuery = async (
+  engine: CubeEngine,
+  query: Query,
+  rowLimit: number,
+  databaseType?: string,
+): Promise<CubeResult> => {
+  TEST__expectValidQuery(query);
+  return engine.execute(
+    CUBE_NORTHWIND_MODEL,
+    new QueryEmitter(query).emitExecutionLambda({
+      rowLimit,
+      runtime: CUBE_NORTHWIND_RUNTIME,
+      databaseType,
+    }),
+  );
+};
+
+/** The values of one column of a result */
+export const TEST__columnValues = (
+  result: CubeResult,
+  column: string,
+): CubeResultValue[] => {
+  const index = result.columns.indexOf(column);
+  expect(index).toBeGreaterThanOrEqual(0);
+  return result.rows.map((row) => row[index] ?? null);
+};
+
+/** The schema Cube infers for a node of the query, its capture node by default */
+export const TEST__inferredSchema = (
+  query: Query,
+  nodeId = query.selected ?? '',
+): Schema => {
+  const schema = buildSchemasAndValidity(
+    query,
+    createNodeRegistry().queryRules,
+  ).schemas.get(nodeId);
+  expect(schema).toBeDefined();
+  return schema as Schema;
+};
+
+/**
+ * The engine types the node as Cube infers it: the same names, in the same
+ * order, of the same types and parameters. Cube's nullability may only be
+ * wider, since the engine misreports it after outer joins (PLAN §4.7).
+ */
+export const TEST__expectEngineTyping = async (
+  engine: CubeEngine,
+  query: Query,
+  nodeId = query.selected ?? '',
+): Promise<void> => {
+  const cube = TEST__inferredSchema(query, nodeId);
+  const typed = (
+    await engine.typeLambdas(
+      CUBE_NORTHWIND_MODEL,
+      new Map([[nodeId, new QueryEmitter(query).emitTypingLambda(nodeId)]]),
+    )
+  ).get(nodeId);
+  expect(typed).toBeInstanceOf(Schema);
+  const engineSchema = typed as Schema;
+  expect(
+    cube.columns.map((column) => [column.name, column.type.fullName]),
+  ).toEqual(
+    engineSchema.columns.map((column) => [column.name, column.type.fullName]),
+  );
+  cube.columns.forEach((column, index) => {
+    if (engineSchema.columns[index]?.nullable) {
+      expect([column.name, column.nullable]).toEqual([column.name, true]);
+    }
+  });
+};

package/src/__test-utils__/FakeCubeEngine.ts

@@ -62,7 +62,13 @@ export const FAKE_NORTHWIND_OUTLINE: CubeModelOutline = {
       ],
     },
   ],
-  runtimes: [{ path: NORTHWIND_RUNTIME, storePaths: [NORTHWIND_DATABASE] }],
+  runtimes: [
+    {
+      path: NORTHWIND_RUNTIME,
+      storePaths: [NORTHWIND_DATABASE],
+      connections: [{ storePath: NORTHWIND_DATABASE, databaseType: 'H2' }],
+    },
+  ],
 };
 
 /** The schemas the fake gives, keyed by `<schema>.<table>` as the outline names them */

package/src/components/CubeNodeIcon.tsx

@@ -15,10 +15,17 @@
  */
 
 import {
+  AlignBottomIcon,
+  AlignMiddleIcon,
+  AlignTopIcon,
   ArrowsJoinIcon,
+  CompressIcon,
+  DataCubeIcon,
   clsx,
   FilterIcon,
+  PencilIcon,
   QuestionSquareIcon,
+  SortIcon,
   TableIcon,
 } from '@finos/legend-art';
 
@@ -29,6 +36,13 @@ const NODE_ICONS: Readonly<
   table: TableIcon,
   filter: FilterIcon,
   join: ArrowsJoinIcon,
+  limit: AlignTopIcon,
+  drop: AlignBottomIcon,
+  slice: AlignMiddleIcon,
+  distinct: CompressIcon,
+  restrict: DataCubeIcon.TableColumns,
+  rename: PencilIcon,
+  sort: SortIcon,
 };
 
 /** Whether a node definition's icon name maps to an icon, rather than the question mark */
@@ -41,7 +55,10 @@ export const CubeNodeIcon: React.FC<{
   className?: string;
 }> = (props) => {
   const { icon, className } = props;
+  // an own key only: a name such as `constructor` must not reach Object's
   const Icon =
-    (icon === undefined ? undefined : NODE_ICONS[icon]) ?? QuestionSquareIcon;
+    icon !== undefined && hasCubeNodeIcon(icon)
+      ? (NODE_ICONS[icon] ?? QuestionSquareIcon)
+      : QuestionSquareIcon;
   return <Icon className={clsx(className)} />;
 };

package/src/components/canvas/CubeCanvas.tsx

@@ -93,14 +93,16 @@ const CubeCanvasFlow = observer((props: { editorState: CubeEditorState }) => {
   );
   const edges = useMemo(() => buildCubeCanvasEdges(query), [query]);
   // the view fits the graph again whenever the layout moves a node, or the
-  // canvas gets wider or narrower (e.g. the node editor opens beside it),
-  // once React Flow has measured every node: it fits only measured ones
+  // canvas changes size (e.g. the node editor opens beside it, or the
+  // splitter above the grid moves), once React Flow has measured every node:
+  // it fits only measured ones
   const layoutSignature = useMemo(
     () => JSON.stringify([...positions]),
     [positions],
   );
   const nodesInitialized = useNodesInitialized();
   const canvasWidth = useStore((state) => state.width);
+  const canvasHeight = useStore((state) => state.height);
   useEffect(() => {
     if (!nodesInitialized) {
       return undefined;
@@ -109,7 +111,7 @@ const CubeCanvasFlow = observer((props: { editorState: CubeEditorState }) => {
       fitView(FIT_VIEW_OPTIONS).catch(noop());
     }, 0);
     return () => window.clearTimeout(timer);
-  }, [layoutSignature, canvasWidth, nodesInitialized, fitView]);
+  }, [layoutSignature, canvasWidth, canvasHeight, nodesInitialized, fitView]);
 
   return (
     <ReactFlow<CubeCanvasFlowNode, CubeCanvasFlowEdge>

package/src/components/canvas/CubeCanvasElements.ts

@@ -117,6 +117,8 @@ export interface CubeCanvasNodeStatus {
   readonly isResolving: boolean;
   /** The last run failed on it */
   readonly hasEngineError: boolean;
+  /** It has a warning, stored (a table that changed) or derived (a lost sort order) */
+  readonly hasWarnings: boolean;
   /** Its errors, then its warnings, its description and its id, one a line */
   readonly tooltip: string;
 }
@@ -128,7 +130,7 @@ export const getCubeCanvasNodeStatus = (
   const ownErrors = editorState.analysis.validity.get(node.id);
   // the tooltip adds the engine's error; the states keep it apart
   const errors = editorState.getNodeErrors(node.id);
-  const warnings = editorState.warnings.get(node.key) ?? [];
+  const warnings = editorState.getNodeWarnings(node);
   return {
     isCapture: editorState.document.query.selected === node.id,
     isInvalid: (ownErrors ?? []).some(
@@ -139,6 +141,7 @@ export const getCubeCanvasNodeStatus = (
     ),
     isResolving: editorState.isPendingSource(node),
     hasEngineError: editorState.hostIssues.has(node.id),
+    hasWarnings: warnings.length > 0,
     tooltip: [
       ...(ownErrors ? [] : [MISSING_VALIDITY_TOOLTIP]),
       ...errors,

package/src/components/canvas/CubeCanvasNode.tsx

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { clsx, ContextMenu } from '@finos/legend-art';
+import { clsx, ContextMenu, WarningIcon } from '@finos/legend-art';
 import { Handle, type NodeProps, Position } from '@xyflow/react';
 import { observer } from 'mobx-react-lite';
 import { useRef } from 'react';
@@ -113,6 +113,7 @@ export const CubeCanvasNode = observer(
               'legend-cube__node--resolving animate-pulse': status.isResolving,
               'legend-cube__node--engine-error bg-[var(--color-status-error-bg)]':
                 status.hasEngineError,
+              'legend-cube__node--warning': status.hasWarnings,
               'legend-cube__node--drop-target outline-dashed outline-2 outline-[var(--color-accent)]':
                 isDropTarget,
             },
@@ -128,6 +129,13 @@ export const CubeCanvasNode = observer(
           <span className="line-clamp-2 min-w-0 break-words leading-tight">
             {node.describe()}
           </span>
+          {status.hasWarnings && (
+            // the warning's text is in the node's tooltip
+            <WarningIcon
+              className="ml-auto shrink-0 text-[var(--color-status-warn)]"
+              aria-hidden={true}
+            />
+          )}
         </div>
         <Handle
           id={CUBE_OUTPUT_HANDLE_ID}

package/src/components/editors/CubeColumnPicker.tsx

@@ -23,7 +23,12 @@ import {
   StringTypeIcon,
   ToggleIcon,
 } from '@finos/legend-art';
-import { type CubeType, type Schema, TypeFamily } from '@finos/legend-cube';
+import {
+  type CubeType,
+  type Schema,
+  type SchemaColumn,
+  TypeFamily,
+} from '@finos/legend-cube';
 import { getColumnTypeLabel } from '../../__lib__/LegendCubeLabels.js';
 
 const FAMILY_ICONS: Readonly<
@@ -55,7 +60,9 @@ export const CubeColumnTypeIcon: React.FC<{
  * columns of the actual input). Each option names its type, e.g.
  * `CUSTOMER_ID: Varchar(5)?`; the picked column's type shows beside, with
  * its family's icon and its full type in the tooltip. A column the input
- * doesn't have stays shown, so the problem can be seen and fixed.
+ * doesn't have stays shown, so the problem can be seen and fixed. A column
+ * the editor can't take here is shown, with the reason `isColumnDisabled`
+ * gives after its type, but can't be picked.
  */
 export const CubeColumnPicker: React.FC<{
   /** What the column is for, e.g. `Left join column 1`: the picker's accessible name */
@@ -67,8 +74,21 @@ export const CubeColumnPicker: React.FC<{
   disabled?: boolean | undefined;
   /** Marks the pick as wrong, e.g. a type that doesn't match */
   invalid?: boolean | undefined;
+  /**
+   * Why a column can't be picked, shown after its type, e.g. a Sort's Variant
+   * column, or one another row has; `undefined` when it can be
+   */
+  isColumnDisabled?: ((column: SchemaColumn) => string | undefined) | undefined;
 }> = (props) => {
-  const { label, schema, value, onChange, disabled, invalid } = props;
+  const {
+    label,
+    schema,
+    value,
+    onChange,
+    disabled,
+    invalid,
+    isColumnDisabled,
+  } = props;
   const picked = value ? schema.lookup(value) : undefined;
   return (
     <div className="flex min-w-0 items-center gap-1">
@@ -90,15 +110,19 @@ export const CubeColumnPicker: React.FC<{
             {value ? `${value} (not in the input)` : 'Pick a column'}
           </option>
         )}
-        {schema.columns.map((column) => (
-          <option
-            key={column.name}
-            value={column.name}
-            title={column.type.fullName}
-          >
-            {`${column.name}: ${getColumnTypeLabel(column)}`}
-          </option>
-        ))}
+        {schema.columns.map((column) => {
+          const reason = isColumnDisabled?.(column);
+          return (
+            <option
+              key={column.name}
+              value={column.name}
+              title={column.type.fullName}
+              disabled={reason !== undefined}
+            >
+              {`${column.name}: ${getColumnTypeLabel(column)}${reason === undefined ? '' : ` (${reason})`}`}
+            </option>
+          );
+        })}
       </select>
       {picked && (
         <span

package/src/components/editors/CubeDistinctEditor.tsx

@@ -0,0 +1,28 @@
+/**
+ * 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 { observer } from 'mobx-react-lite';
+import { DISTINCT_EDITOR_TEXT } from '../../__lib__/LegendCubeLabels.js';
+
+/**
+ * The Distinct editor (spec §17.6: "nothing — description only"). Distinct
+ * has no settings, so it has no draft, and the panel shows no Apply or Cancel.
+ */
+export const CubeDistinctEditor = observer(() => (
+  <div className="text-base text-[var(--color-text-secondary)]">
+    {DISTINCT_EDITOR_TEXT}
+  </div>
+));

package/src/components/editors/CubeIntegerField.tsx

@@ -0,0 +1,51 @@
+/**
+ * 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 { clsx } from '@finos/legend-art';
+
+/**
+ * A field for a whole number, such as a size or a row index. It shows the
+ * text as typed and reports every keystroke, so the panel checks the edited
+ * node as the user types. Enter and Escape do nothing special: Apply is the
+ * panel's, and Ctrl+Z is the field's own undo.
+ */
+export const CubeIntegerField: React.FC<{
+  label: string;
+  text: string;
+  invalid: boolean;
+  disabled: boolean;
+  onChange: (text: string) => void;
+}> = (props) => {
+  const { label, text, invalid, disabled, onChange } = props;
+  return (
+    <input
+      aria-label={label}
+      aria-invalid={invalid}
+      className={clsx(
+        'h-6 w-24 rounded-sm border bg-[var(--color-bg-input)] px-1 text-base',
+        invalid
+          ? 'border-[var(--color-status-error)] text-[var(--color-status-error)]'
+          : 'border-[var(--color-border-default)]',
+      )}
+      type="text"
+      inputMode="numeric"
+      spellCheck={false}
+      value={text}
+      disabled={disabled}
+      onChange={(event) => onChange(event.target.value)}
+    />
+  );
+};

package/src/components/editors/CubeJoinEditor.tsx

@@ -21,13 +21,17 @@ import {
   isJoinType,
   JOIN_TYPE_LABELS,
   JOIN_TYPES,
+  planJoinDuplicateFix,
   type Schema,
 } from '@finos/legend-cube';
 import { guaranteeType, noop } from '@finos/legend-shared';
 import { flowResult } from 'mobx';
 import { observer } from 'mobx-react-lite';
 import { useEffect } from 'react';
-import { CUBE_TABLE_FLAG_LABELS } from '../../__lib__/LegendCubeLabels.js';
+import {
+  CUBE_TABLE_FLAG_LABELS,
+  READ_ONLY_CUBE_TITLE,
+} from '../../__lib__/LegendCubeLabels.js';
 import { CubeTableFlag } from '../../graph-manager/CubeEngine.js';
 import {
   type CubeJoinKeyPair,
@@ -137,6 +141,10 @@ export const CubeJoinEditor = observer((props: CubeNodeEditorProps) => {
     edited.leftColumns,
     edited.rightColumns,
   );
+  // the names the autofix would give, to show beside each shared column
+  const fix = duplicates.length
+    ? planJoinDuplicateFix(edited, leftSchema, rightSchema)
+    : undefined;
   const canAddPair =
     !readOnly &&
     draft.pairs.length <
@@ -211,12 +219,27 @@ export const CubeJoinEditor = observer((props: CubeNodeEditorProps) => {
             both:
           </div>
           <ul aria-label="Columns in both inputs">
-            {duplicates.map((name) => (
+            {duplicates.map((name, index) => (
               <li key={name} className="font-mono">
-                {name}
+                {fix
+                  ? `${name} → ${fix.left[index]?.to} (Left), ${fix.right[index]?.to} (Right)`
+                  : name}
               </li>
             ))}
           </ul>
+          <div className="mt-1">
+            <CubeButton
+              title={
+                readOnly
+                  ? READ_ONLY_CUBE_TITLE
+                  : 'Add a Rename before each input that gives these columns new names. Applies your changes too, as one step to undo.'
+              }
+              disabled={!editorState.nodeEditor.canRenameDuplicateColumns}
+              onClick={() => editorState.nodeEditor.renameDuplicateColumns()}
+            >
+              Rename them
+            </CubeButton>
+          </div>
         </div>
       )}
     </div>

package/src/components/editors/CubeNodeEditorPanel.tsx

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { QuestionCircleIcon, TimesIcon } from '@finos/legend-art';
+import { QuestionCircleIcon, TimesIcon, WarningIcon } from '@finos/legend-art';
 import {
   isIncompleteError,
   isSchemasError,
@@ -80,6 +80,7 @@ export const CubeNodeEditorPanel = observer(
       isEditable && !inputProblems.length
         ? validateEdited(edited, inputSchemas)
         : [];
+    const warnings = editorState.getNodeWarnings(node);
     return (
       <div
         className="flex h-full flex-col border-l border-[var(--color-border-default)] bg-[var(--color-bg-panel)]"
@@ -143,6 +144,16 @@ export const CubeNodeEditorPanel = observer(
           </button>
         </div>
         <div className="min-h-0 flex-1 overflow-auto p-2">
+          {warnings.map((warning) => (
+            <div
+              key={warning}
+              className="mb-2 flex gap-1 text-sm text-[var(--color-status-warn)]"
+              role="status"
+            >
+              <WarningIcon className="mt-0.5 shrink-0" aria-hidden={true} />
+              <span>{warning}</span>
+            </div>
+          ))}
           {inputProblems.length ? (
             <div
               className="text-base text-[var(--color-status-warn)]"

package/src/components/editors/CubeNodeEditorRegistry.ts

@@ -15,15 +15,28 @@
  */
 
 import {
+  Distinct,
+  Drop,
   Filter,
   Join,
+  Limit,
   RelationalTableSource,
+  Rename,
+  Restrict,
   type Schema,
+  Slice,
+  Sort,
 } from '@finos/legend-cube';
 import type { CubeEditorState } from '../../stores/CubeEditorState.js';
 import type { CubeNodeDraft } from '../../stores/editors/CubeNodeDraft.js';
+import { CubeDistinctEditor } from './CubeDistinctEditor.js';
 import { CubeFilterEditor } from './CubeFilterEditor.js';
 import { CubeJoinEditor } from './CubeJoinEditor.js';
+import { CubeRenameEditor } from './CubeRenameEditor.js';
+import { CubeRestrictEditor } from './CubeRestrictEditor.js';
+import { CubeRowCountEditor } from './CubeRowCountEditor.js';
+import { CubeSliceEditor } from './CubeSliceEditor.js';
+import { CubeSortEditor } from './CubeSortEditor.js';
 import { CubeSourceEditor } from './CubeSourceEditor.js';
 
 /**
@@ -56,6 +69,13 @@ export const CUBE_NODE_EDITORS: ReadonlyMap<
   React.FC<CubeNodeEditorProps>
 > = new Map<string, React.FC<CubeNodeEditorProps>>([
   [RelationalTableSource.TYPE, CubeSourceEditor],
+  [Sort.TYPE, CubeSortEditor],
   [Filter.TYPE, CubeFilterEditor],
+  [Restrict.TYPE, CubeRestrictEditor],
+  [Rename.TYPE, CubeRenameEditor],
+  [Distinct.TYPE, CubeDistinctEditor],
   [Join.TYPE, CubeJoinEditor],
+  [Drop.TYPE, CubeRowCountEditor],
+  [Limit.TYPE, CubeRowCountEditor],
+  [Slice.TYPE, CubeSliceEditor],
 ]);