@finos/legend-cube-builder 0.0.2 → 0.0.4

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 */
@@ -93,6 +99,8 @@ export interface FakeCubeEngine {
   readonly typeLambdas: jest.Mock<CubeEngine['typeLambdas']>;
   readonly execute: jest.Mock<CubeEngine['execute']>;
   readonly renderPure: jest.Mock<CubeEngine['renderPure']>;
+  readonly parseExpression: jest.Mock<CubeEngine['parseExpression']>;
+  readonly planLambda: jest.Mock<CubeEngine['planLambda']>;
 }
 
 /** A fresh fake: build one per test, since jest.fn keeps its calls across tests */
@@ -128,12 +136,34 @@ export const createFakeCubeEngine = (
   const renderPure = jest.fn<CubeEngine['renderPure']>(async () =>
     Promise.resolve(answers.pure ?? ''),
   );
+  // a test that types expressions says how; by default, each parses to nothing
+  const parseExpression = jest.fn<CubeEngine['parseExpression']>(async () =>
+    Promise.reject(
+      new CubeEngineError(
+        CubeEngineErrorKind.COMPILE,
+        'The fake engine parses no expression',
+      ),
+    ),
+  );
+  const planLambda = jest.fn<CubeEngine['planLambda']>(async () =>
+    Promise.resolve(),
+  );
   return {
-    engine: { loadModel, resolveSchemas, typeLambdas, execute, renderPure },
+    engine: {
+      loadModel,
+      resolveSchemas,
+      typeLambdas,
+      execute,
+      renderPure,
+      parseExpression,
+      planLambda,
+    },
     loadModel,
     resolveSchemas,
     typeLambdas,
     execute,
     renderPure,
+    parseExpression,
+    planLambda,
   };
 };

package/src/__test-utils__/FakeCubeIngestCatalog.ts

@@ -0,0 +1,180 @@
+/**
+ * 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 { jest } from '@jest/globals';
+import { PrimitiveType, Schema, SchemaColumn } from '@finos/legend-cube';
+import { CubeDataProductEnvironmentType } from '../graph-manager/CubeDataProduct.js';
+import {
+  CubeEngineError,
+  CubeEngineErrorKind,
+} from '../graph-manager/CubeEngine.js';
+import {
+  type CubeIngestCatalog,
+  CubeIngestDataSet,
+  CubeIngestDefinitionCandidate,
+  CubeIngestEnvironment,
+  CubeIngestProducer,
+} from '../graph-manager/CubeIngestCatalog.js';
+
+// A fake of the deployed ingest definitions, for the Ingest tab's and the
+// editor's tests: producer deployment 1234 deploys two definitions from
+// com.example:sales, 5678 none
+
+const { PRODUCTION, PRODUCTION_PARALLEL } = CubeDataProductEnvironmentType;
+
+export const FAKE_INGEST_ORDERS = 'sales::ingest::OrdersIngest';
+export const FAKE_INGEST_DESKS = 'sales::ingest::DesksIngest';
+
+export const fakeIngestUrnOf = (
+  definition: string,
+  environmentType = PRODUCTION,
+): string =>
+  `urn:lakehouse:${environmentType === PRODUCTION ? 'prod' : 'prod-parallel'}:ingest:definition:alloy-git:com.example~sales~${definition}`;
+
+export const FAKE_INGEST_TRADES_SCHEMA = new Schema([
+  new SchemaColumn('TRADE_ID', PrimitiveType.get('Integer'), false),
+  new SchemaColumn(
+    'DESK',
+    PrimitiveType.get('meta::pure::precisePrimitives::Varchar', [20]),
+    true,
+  ),
+]);
+
+export const FAKE_INGEST_DESKS_SCHEMA = new Schema([
+  new SchemaColumn('DESK', PrimitiveType.get('String'), false),
+]);
+
+const DATA_SETS: ReadonlyMap<string, readonly CubeIngestDataSet[]> = new Map([
+  [
+    FAKE_INGEST_ORDERS,
+    [
+      new CubeIngestDataSet({
+        name: 'TRADES',
+        schema: FAKE_INGEST_TRADES_SCHEMA,
+        primaryKey: ['TRADE_ID'],
+      }),
+      new CubeIngestDataSet({
+        name: 'DAILY',
+        disabledReason:
+          'It is a materialized view, which Cube does not support yet',
+      }),
+    ],
+  ],
+  [
+    FAKE_INGEST_DESKS,
+    [
+      new CubeIngestDataSet({
+        name: 'DESKS',
+        schema: FAKE_INGEST_DESKS_SCHEMA,
+      }),
+    ],
+  ],
+]);
+
+const definitionOf = (urn: string): string =>
+  urn.slice(urn.lastIndexOf('~') + 1);
+
+export interface FakeCubeIngestCatalog {
+  catalog: CubeIngestCatalog;
+  resolveEnvironment: jest.Mock<CubeIngestCatalog['resolveEnvironment']>;
+  listProducers: jest.Mock<CubeIngestCatalog['listProducers']>;
+  listDefinitions: jest.Mock<CubeIngestCatalog['listDefinitions']>;
+  describe: jest.Mock<CubeIngestCatalog['describe']>;
+  resolveSchemas: jest.Mock<CubeIngestCatalog['resolveSchemas']>;
+}
+
+/** A fresh fake: build one per test, since jest.fn keeps its calls across tests */
+export const createFakeCubeIngestCatalog = (): FakeCubeIngestCatalog => {
+  const resolveEnvironment = jest.fn<CubeIngestCatalog['resolveEnvironment']>(
+    async (environmentType) =>
+      Promise.resolve(
+        new CubeIngestEnvironment({
+          environmentType,
+          name: 'env-a',
+          runtimeEnvironment:
+            environmentType === PRODUCTION_PARALLEL
+              ? 'lakehouse-ingest-env-a-pp'
+              : 'lakehouse-ingest-env-a',
+        }),
+      ),
+  );
+  const listProducers = jest.fn<CubeIngestCatalog['listProducers']>(async () =>
+    Promise.resolve(
+      ['1234', '5678'].map(
+        (deploymentId) =>
+          new CubeIngestProducer({
+            deploymentId,
+            urn: `urn:lakehouse:prod:producer:deployment:${deploymentId}`,
+          }),
+      ),
+    ),
+  );
+  const listDefinitions = jest.fn<CubeIngestCatalog['listDefinitions']>(
+    async (environmentType, producerDeploymentId) =>
+      Promise.resolve(
+        producerDeploymentId === '1234'
+          ? {
+              candidates: [FAKE_INGEST_ORDERS, FAKE_INGEST_DESKS].map(
+                (definition) =>
+                  new CubeIngestDefinitionCandidate({
+                    urn: fakeIngestUrnOf(definition, environmentType),
+                    definition,
+                    groupId: 'com.example',
+                    artifactId: 'sales',
+                  }),
+              ),
+              droppedCount: 1,
+            }
+          : { candidates: [], droppedCount: 0 },
+      ),
+  );
+  const describe = jest.fn<CubeIngestCatalog['describe']>(async (urn) =>
+    Promise.resolve(DATA_SETS.get(definitionOf(urn)) ?? []),
+  );
+  const resolveSchemas = jest.fn<CubeIngestCatalog['resolveSchemas']>(
+    async (_environmentType, sources) =>
+      Promise.resolve(
+        new Map(
+          [...sources].map(([nodeId, source]) => [
+            nodeId,
+            DATA_SETS.get(source.ingestDefinition)?.find(
+              (dataSet) => dataSet.name === source.dataSet,
+            )?.schema ??
+              new CubeEngineError(
+                CubeEngineErrorKind.COMPILE,
+                `Ingest definition ${source.ingestDefinition} has no data set ${source.dataSet}`,
+                nodeId,
+              ),
+          ]),
+        ),
+      ),
+  );
+  return {
+    catalog: {
+      environmentTypes: [PRODUCTION, PRODUCTION_PARALLEL],
+      resolveEnvironment,
+      listProducers,
+      listDefinitions,
+      describe,
+      resolveSchemas,
+    },
+    resolveEnvironment,
+    listProducers,
+    listDefinitions,
+    describe,
+    resolveSchemas,
+  };
+};

package/src/__test-utils__/FakeCubeProjectCatalog.ts

@@ -0,0 +1,89 @@
+/**
+ * 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 { jest } from '@jest/globals';
+import type { CubeModelOutline } from '../graph-manager/CubeEngine.js';
+import type { CubeProjectCatalog } from '../graph-manager/CubeProjectCatalog.js';
+import { FAKE_NORTHWIND_OUTLINE } from './FakeCubeEngine.js';
+
+// A fake of the depot's published projects, for the Project tab's and the
+// editor's tests: com.example:sales at 1.10.0 and 1.9.0 holds the fake
+// engine's Northwind Database (so the fake types its tables) and a Database
+// no runtime connects to; com.example:reference has one version
+
+export const FAKE_PROJECT_GROUP = 'com.example';
+export const FAKE_PLANNED_DATABASE = 'sales::store::PlannedDb';
+
+export const FAKE_SALES_OUTLINE: CubeModelOutline = {
+  databases: [
+    ...FAKE_NORTHWIND_OUTLINE.databases,
+    {
+      path: FAKE_PLANNED_DATABASE,
+      schemas: [
+        {
+          name: 'PLANNED',
+          tables: [
+            {
+              name: 'FORECASTS',
+              isView: false,
+              columnCount: 2,
+              flags: [],
+              untypedColumns: [],
+            },
+          ],
+        },
+      ],
+    },
+  ],
+  runtimes: FAKE_NORTHWIND_OUTLINE.runtimes,
+};
+
+export interface FakeCubeProjectCatalog {
+  readonly catalog: CubeProjectCatalog;
+  readonly listProjects: jest.Mock<CubeProjectCatalog['listProjects']>;
+  readonly listVersions: jest.Mock<CubeProjectCatalog['listVersions']>;
+  readonly loadOutline: jest.Mock<CubeProjectCatalog['loadOutline']>;
+}
+
+/** A fresh fake: build one per test, since jest.fn keeps its calls across tests */
+export const createFakeCubeProjectCatalog = (): FakeCubeProjectCatalog => {
+  const listProjects = jest.fn<CubeProjectCatalog['listProjects']>(async () =>
+    Promise.resolve([
+      { groupId: FAKE_PROJECT_GROUP, artifactId: 'reference' },
+      { groupId: FAKE_PROJECT_GROUP, artifactId: 'sales' },
+    ]),
+  );
+  const listVersions = jest.fn<CubeProjectCatalog['listVersions']>(
+    async (project) =>
+      Promise.resolve(
+        project.artifactId === 'sales' ? ['1.10.0', '1.9.0'] : ['2.0.0'],
+      ),
+  );
+  const loadOutline = jest.fn<CubeProjectCatalog['loadOutline']>(
+    async (project) =>
+      Promise.resolve(
+        project.artifactId === 'sales'
+          ? FAKE_SALES_OUTLINE
+          : { databases: [], runtimes: [] },
+      ),
+  );
+  return {
+    catalog: { listProjects, listVersions, loadOutline },
+    listProjects,
+    listVersions,
+    loadOutline,
+  };
+};

package/src/components/CubeAddItems.tsx

@@ -0,0 +1,179 @@
+/**
+ * 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,
+  clsx,
+  DropdownMenu,
+  DropdownMenuItem,
+  MenuContentDivider,
+  MenuContentItem,
+  MenuContentItemIcon,
+  MenuContentItemLabel,
+  useDropdownMenu,
+} from '@finos/legend-art';
+import type { AnyNodeDefinition } from '@finos/legend-cube';
+import { observer } from 'mobx-react-lite';
+import {
+  OTHER_SOURCE_KIND_TITLE,
+  READ_ONLY_CUBE_TITLE,
+} from '../__lib__/LegendCubeLabels.js';
+import { addCubeNode, canAddCubeNode } from '../stores/CubeAddPlacement.js';
+import type { CubeEditorState } from '../stores/CubeEditorState.js';
+import { CubeNodeIcon } from './CubeNodeIcon.js';
+
+/** An item that adds a node, as the palette, the context menu and 'Add Items' list it */
+interface CubeAddItem {
+  readonly definition: AnyNodeDefinition;
+  readonly label: string;
+  readonly disabled: boolean;
+  /** Why a source can't be added */
+  readonly title: string | undefined;
+  readonly add: () => void;
+}
+
+/**
+ * The items that add a node, as the palette lists them (spec §17.2): the
+ * sources the cube can take, then the transforms. Each adds where the
+ * placement rule puts it (PLAN §11.8): after `nodeId` when given, else after
+ * the selected node; a source opens the source dialog on its tab. An item
+ * that can't be added is listed, disabled; a source says why. Read in an
+ * observer's render.
+ */
+const getCubeAddItems = (
+  editorState: CubeEditorState,
+  nodeId?: string,
+): { sources: CubeAddItem[]; transforms: CubeAddItem[] } => {
+  const item = (definition: AnyNodeDefinition): CubeAddItem => {
+    const disabled = !canAddCubeNode(editorState, definition.type, nodeId);
+    return {
+      definition,
+      label: `${definition.label}${definition.beta ? ' (BETA)' : ''}`,
+      disabled,
+      title:
+        disabled && definition.kind === 'source'
+          ? (editorState.sourcePicker.disabledReason ?? OTHER_SOURCE_KIND_TITLE)
+          : undefined,
+      add: () => addCubeNode(editorState, definition.type, nodeId),
+    };
+  };
+  return {
+    sources: editorState.offeredSources.map(item),
+    transforms: editorState.registry.transforms.map(item),
+  };
+};
+
+/** The items, as the canvas's context menu lists them (spec §17.4) */
+export const CubeAddMenuItems = observer(
+  (props: { editorState: CubeEditorState; nodeId?: string | undefined }) => {
+    const { sources, transforms } = getCubeAddItems(
+      props.editorState,
+      props.nodeId,
+    );
+    const menuItem = (item: CubeAddItem): React.ReactNode => (
+      <MenuContentItem
+        key={item.definition.type}
+        disabled={item.disabled}
+        title={item.title}
+        onClick={item.add}
+      >
+        <MenuContentItemIcon>
+          <CubeNodeIcon icon={item.definition.icon} />
+        </MenuContentItemIcon>
+        <MenuContentItemLabel>{item.label}</MenuContentItemLabel>
+      </MenuContentItem>
+    );
+    return (
+      <>
+        {sources.map(menuItem)}
+        <MenuContentDivider />
+        {transforms.map(menuItem)}
+      </>
+    );
+  },
+);
+
+/**
+ * 'Add Items ▾' in the graph's header (spec §17.1, QUESTIONS.md U3(a)): the
+ * palette's items, a transform added after the selected node, a source
+ * through the source dialog. It opens no node editor. Its menu takes the
+ * arrow keys, Enter and Escape, and gives the focus back to its button.
+ */
+export const CubeAddItemsMenu = observer(
+  (props: { editorState: CubeEditorState }) => {
+    const { editorState } = props;
+    const { readOnly } = editorState;
+    const [openMenu, closeMenu, menuProps, isOpen] = useDropdownMenu();
+    const { sources, transforms } = getCubeAddItems(editorState);
+    const menuItem = (item: CubeAddItem): React.ReactNode => (
+      <DropdownMenuItem
+        key={item.definition.type}
+        className={clsx(
+          'flex items-center gap-2 px-2 text-base',
+          item.disabled && '!cursor-not-allowed opacity-50',
+        )}
+        // not MUI's disabled, which takes the pointer away: a disabled
+        // source's reason shows on hover
+        aria-disabled={item.disabled}
+        title={item.title}
+        onClick={() => {
+          if (!item.disabled) {
+            closeMenu();
+            item.add();
+          }
+        }}
+      >
+        <CubeNodeIcon icon={item.definition.icon} />
+        <span>{item.label}</span>
+      </DropdownMenuItem>
+    );
+    return (
+      <>
+        <button
+          type="button"
+          className="flex h-6 shrink-0 items-center gap-1 rounded-sm border border-[var(--color-border-default)] bg-[var(--color-bg-elevated)] px-2 text-base text-[var(--color-text-primary)] enabled:cursor-pointer enabled:hover:bg-[var(--color-bg-hover)] disabled:cursor-not-allowed disabled:text-[var(--color-text-disabled)]"
+          disabled={readOnly}
+          title={
+            readOnly
+              ? READ_ONLY_CUBE_TITLE
+              : 'Add a source, or a step after the selected node'
+          }
+          aria-haspopup="menu"
+          aria-expanded={isOpen}
+          onClick={openMenu}
+        >
+          Add Items
+          <CaretDownIcon aria-hidden={true} />
+        </button>
+        <DropdownMenu
+          {...menuProps}
+          menuProps={{
+            elevation: 7,
+            slotProps: {
+              root: { slotProps: { backdrop: { invisible: true } } },
+              // the keyboard reaches a disabled source too, to read why
+              list: { disabledItemsFocusable: true },
+            },
+          }}
+        >
+          {sources.map(menuItem)}
+          <MenuContentDivider />
+          {transforms.map(menuItem)}
+        </DropdownMenu>
+      </>
+    );
+  },
+);