@finos/legend-cube-builder 0.0.4 → 0.0.5

package/src/__test-utils__/CubeLambdaCorpus.ts

@@ -0,0 +1,137 @@
+/**
+ * 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 {
+  buildSchemasAndValidity,
+  CubeLambdaReadError,
+  decodeCubeSpec,
+  ExpressionFilter,
+  getExpressionFilterSignature,
+  lambda,
+  QueryEmitter,
+  RelationalTableSource,
+  type CubeDocument,
+  type CubeSourceStep,
+  type IR,
+  type Query,
+} from '@finos/legend-cube';
+import { readdirSync, readFileSync } from 'fs';
+import { join, resolve } from 'path';
+
+// The lambdas Cube writes for the core's saved spec samples (PLAN §10.3),
+// for Import Pure's round trips (PLAN §11.18): for each node that can be
+// written, as a matview saves it and as Show Pure shows a run of it
+
+const FIXTURES = resolve(
+  __dirname,
+  '../../../legend-cube/src/spec/__tests__/fixtures',
+);
+
+export interface TEST__CubeLambdaSample {
+  /** `<file>/<node id>` */
+  readonly key: string;
+  readonly document: CubeDocument;
+  readonly nodeId: string;
+  /** The node's relation, as a matview saves it: `{| <relation>}`, written with its rows' order */
+  readonly relation: IR;
+  /** A run of the node with no row limit, as Show Pure shows it: lets, the capture's sort, `from()` */
+  readonly run: IR;
+}
+
+/** Every node of every sample that can be written, by key */
+export const TEST__cubeLambdaSamples = (): TEST__CubeLambdaSample[] =>
+  readdirSync(FIXTURES)
+    .filter((file) => file.endsWith('.cube.json'))
+    .sort()
+    .flatMap((file) => {
+      const { document } = decodeCubeSpec(
+        JSON.parse(readFileSync(join(FIXTURES, file), 'utf-8')),
+      );
+      const runtime = document.context?.runtime;
+      if (runtime === undefined) {
+        return [];
+      }
+      const emitter = new QueryEmitter(document.query);
+      return document.query.nodes
+        .filter((node) => emitter.canEmit(node.id))
+        .map((node) => ({
+          key: `${file}/${node.id}`,
+          document,
+          nodeId: node.id,
+          relation: lambda(
+            [],
+            [emitter.emitRelation(node.id, { withRowOrder: true })],
+          ),
+          run: new QueryEmitter(
+            document.query.selected === node.id
+              ? document.query
+              : document.query.select(node.id),
+          ).emitExecutionLambda({ runtime }),
+        }));
+    });
+
+/** Each table of the lambda bound to the sample's own source of it, with its saved columns */
+export const TEST__bindSampleSources =
+  (document: CubeDocument) =>
+  (source: IR): CubeSourceStep => {
+    const table = document.query.nodes.find(
+      (node): node is RelationalTableSource =>
+        node instanceof RelationalTableSource &&
+        source.k === 'storeAccessor' &&
+        source.path.join('.') ===
+          [node.database, node.schema, node.table].join('.'),
+    );
+    if (!table) {
+      throw new CubeLambdaReadError(`No table for ${JSON.stringify(source)}`);
+    }
+    return {
+      type: RelationalTableSource.TYPE,
+      create: (id) =>
+        new RelationalTableSource(
+          id,
+          {
+            database: table.database,
+            schema: table.schema,
+            table: table.table,
+          },
+          table.resolution,
+        ),
+    };
+  };
+
+/**
+ * The query with each Filter by Expression checked, as the editor has the
+ * engine check them on import: the samples' conditions are all Booleans
+ */
+export const TEST__checkedAsTheEngineWould = (query: Query): Query =>
+  query.nodes.reduce((checked, node) => {
+    if (!(node instanceof ExpressionFilter) || !node.lambda) {
+      return checked;
+    }
+    const [inputId] = checked.getInputIds(node.id);
+    const input =
+      inputId === undefined
+        ? undefined
+        : buildSchemasAndValidity(checked).schemas.get(inputId);
+    return input
+      ? checked.replace(
+          node.withCheck({
+            kind: 'checked',
+            signature: getExpressionFilterSignature(input, node.lambda),
+          }),
+        )
+      : checked;
+  }, query);

package/src/__test-utils__/CubePageTestUtils.tsx

@@ -129,3 +129,37 @@ export const TEST__closeAddItems = async (): Promise<void> => {
   fireEvent.keyDown(screen.getByRole('menu'), { key: 'Escape' });
   await waitFor(() => expect(screen.queryByRole('menu')).toBeNull());
 };
+
+/** Opens 'Cube' (New, Import, Export) in the graph's header and returns its menu */
+export const TEST__openCubeMenu = async (): Promise<HTMLElement> => {
+  fireEvent.click(
+    within(screen.getByTestId(LEGEND_CUBE_TEST_ID.GRAPH_REGION)).getByRole(
+      'button',
+      { name: 'Cube' },
+    ),
+  );
+  return screen.findByRole('menu');
+};
+
+/** Chooses an item of the 'Cube' menu (New, Import or Export), and waits for the menu to close */
+export const TEST__chooseCubeMenuItem = async (
+  label: string,
+): Promise<void> => {
+  const menu = await TEST__openCubeMenu();
+  fireEvent.click(within(menu).getByRole('menuitem', { name: label }));
+  await waitFor(() => expect(screen.queryByRole('menu')).toBeNull());
+};
+
+/** Whether an item of the 'Cube' menu is disabled; the menu is closed again */
+export const TEST__isCubeMenuItemDisabled = async (
+  label: string,
+): Promise<boolean> => {
+  const menu = await TEST__openCubeMenu();
+  const disabled =
+    within(menu)
+      .getByRole('menuitem', { name: label })
+      .getAttribute('aria-disabled') === 'true';
+  fireEvent.keyDown(menu, { key: 'Escape' });
+  await waitFor(() => expect(screen.queryByRole('menu')).toBeNull());
+  return disabled;
+};

package/src/__test-utils__/CubeTestApplication.ts

@@ -22,6 +22,11 @@ import {
   LegendApplicationPluginManager,
 } from '@finos/legend-application';
 import { TEST__getApplicationVersionData } from '@finos/legend-application/test';
+import { jest } from '@jest/globals';
+import {
+  type CubeEngineClientControls,
+  CubeEngineClientSettings,
+} from '../graph-manager/CubeEngineClientSettings.js';
 import type { CubeHost } from '../stores/CubeHost.js';
 import { LocalModelCatalog } from '../stores/LocalModelCatalog.js';
 import {
@@ -73,6 +78,9 @@ export const TEST__createCubeApplicationStore = (
   );
 };
 
+/** The engine URL a test host is configured with */
+export const TEST__CUBE_ENGINE_URL = 'http://localhost:6300/api';
+
 /** A host over fakes of the engine, the connection explorer and the data product catalog, with the bundled models */
 export const TEST__createCubeHost = (
   answers?: FakeCubeEngineAnswers,
@@ -82,8 +90,23 @@ export const TEST__createCubeHost = (
   fake: FakeCubeEngine;
   connections: FakeCubeConnectionExplorer;
   dataProducts: FakeCubeDataProductCatalog;
+  /** An engine client registered with the host's engine client settings */
+  engineClient: {
+    setBaseUrl: jest.Mock<CubeEngineClientControls['setBaseUrl']>;
+    setCompression: jest.Mock<CubeEngineClientControls['setCompression']>;
+  };
 } => {
   const fake = createFakeCubeEngine(answers);
+  const engineClientSettings = new CubeEngineClientSettings({
+    baseUrl: TEST__CUBE_ENGINE_URL,
+    enableCompression: true,
+  });
+  const engineClient = {
+    setBaseUrl: jest.fn<CubeEngineClientControls['setBaseUrl']>(),
+    setCompression: jest.fn<CubeEngineClientControls['setCompression']>(),
+  };
+  engineClientSettings.register(engineClient);
+  engineClient.setCompression.mockClear();
   const connections = createFakeCubeConnectionExplorer();
   const dataProducts = createFakeCubeDataProductCatalog();
   return {
@@ -93,9 +116,11 @@ export const TEST__createCubeHost = (
       modelCatalog: new LocalModelCatalog(fake.engine),
       connectionExplorer: connections.explorer,
       dataProductCatalog: dataProducts.catalog,
+      engineClientSettings,
     },
     fake,
     connections,
     dataProducts,
+    engineClient,
   };
 };

package/src/__test-utils__/FakeCubeEngine.ts

@@ -71,6 +71,20 @@ export const FAKE_NORTHWIND_OUTLINE: CubeModelOutline = {
   ],
 };
 
+/** The Northwind outline, its runtime's connection of this database type */
+export const createFakeNorthwindOutline = (
+  databaseType: string,
+): CubeModelOutline => ({
+  ...FAKE_NORTHWIND_OUTLINE,
+  runtimes: [
+    {
+      path: NORTHWIND_RUNTIME,
+      storePaths: [NORTHWIND_DATABASE],
+      connections: [{ storePath: NORTHWIND_DATABASE, databaseType }],
+    },
+  ],
+});
+
 /** The schemas the fake gives, keyed by `<schema>.<table>` as the outline names them */
 export const FAKE_NORTHWIND_SCHEMAS: ReadonlyMap<string, Schema> = new Map([
   ['NORTHWIND.ORDERS', new Schema(ORDERS_COLUMNS)],
@@ -89,6 +103,7 @@ export interface FakeCubeEngineAnswers {
   /** keyed by `<schema>.<table>`; a table not in it gets a compile error */
   readonly schemas?: ReadonlyMap<string, Schema>;
   readonly result?: CubeResult;
+  readonly csv?: string;
   readonly pure?: string;
 }
 
@@ -98,7 +113,9 @@ export interface FakeCubeEngine {
   readonly resolveSchemas: jest.Mock<CubeEngine['resolveSchemas']>;
   readonly typeLambdas: jest.Mock<CubeEngine['typeLambdas']>;
   readonly execute: jest.Mock<CubeEngine['execute']>;
+  readonly exportCsv: jest.Mock<CubeEngine['exportCsv']>;
   readonly renderPure: jest.Mock<CubeEngine['renderPure']>;
+  readonly serializeLambda: jest.Mock<CubeEngine['serializeLambda']>;
   readonly parseExpression: jest.Mock<CubeEngine['parseExpression']>;
   readonly planLambda: jest.Mock<CubeEngine['planLambda']>;
 }
@@ -133,9 +150,15 @@ export const createFakeCubeEngine = (
   const execute = jest.fn<CubeEngine['execute']>(async () =>
     Promise.resolve(answers.result ?? EMPTY_CUBE_RESULT),
   );
+  const exportCsv = jest.fn<CubeEngine['exportCsv']>(async () =>
+    Promise.resolve(answers.csv ?? ''),
+  );
   const renderPure = jest.fn<CubeEngine['renderPure']>(async () =>
     Promise.resolve(answers.pure ?? ''),
   );
+  const serializeLambda = jest.fn<CubeEngine['serializeLambda']>((lambda) =>
+    JSON.stringify(lambda, undefined, 2),
+  );
   // a test that types expressions says how; by default, each parses to nothing
   const parseExpression = jest.fn<CubeEngine['parseExpression']>(async () =>
     Promise.reject(
@@ -154,7 +177,9 @@ export const createFakeCubeEngine = (
       resolveSchemas,
       typeLambdas,
       execute,
+      exportCsv,
       renderPure,
+      serializeLambda,
       parseExpression,
       planLambda,
     },
@@ -162,7 +187,9 @@ export const createFakeCubeEngine = (
     resolveSchemas,
     typeLambdas,
     execute,
+    exportCsv,
     renderPure,
+    serializeLambda,
     parseExpression,
     planLambda,
   };

package/src/__test-utils__/FakeCubeIngestCatalog.ts

@@ -84,6 +84,24 @@ const DATA_SETS: ReadonlyMap<string, readonly CubeIngestDataSet[]> = new Map([
   ],
 ]);
 
+export const FAKE_INGEST_FILLS_SCHEMA = new Schema([
+  new SchemaColumn('FILL_ID', PrimitiveType.get('Integer'), false),
+  new SchemaColumn('QUANTITY', PrimitiveType.get('Integer'), false),
+]);
+
+/**
+ * The orders definition's data sets with a second one that can be added,
+ * FILLS, for picking several at once: what `describe` gives when mocked so
+ */
+export const FAKE_INGEST_ORDERS_WITH_FILLS: readonly CubeIngestDataSet[] = [
+  ...(DATA_SETS.get(FAKE_INGEST_ORDERS) ?? []),
+  new CubeIngestDataSet({
+    name: 'FILLS',
+    schema: FAKE_INGEST_FILLS_SCHEMA,
+    primaryKey: ['FILL_ID'],
+  }),
+];
+
 const definitionOf = (urn: string): string =>
   urn.slice(urn.lastIndexOf('~') + 1);
 

package/src/__test-utils__/FakeCubeServiceCatalog.ts

@@ -0,0 +1,57 @@
+/**
+ * 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 {
+  CubeServiceCatalog,
+  CubeServiceSummary,
+} from '../graph-manager/CubeServiceCatalog.js';
+
+// A fake of the engine's service registry, for the Service tab's and the
+// editor's tests: two trading services, one without a title
+
+export const FAKE_TRADES_SERVICE: CubeServiceSummary = {
+  name: 'trading::services::TradesByDesk',
+  title: 'Trades by desk',
+  pattern: '/trades/byDesk',
+  documentation: 'Every trade, by desk',
+  owners: ['alice', 'bob'],
+};
+
+export const FAKE_DESKS_SERVICE: CubeServiceSummary = {
+  name: 'trading::services::Desks',
+  pattern: '/desks',
+  documentation: '',
+  owners: ['Deployment 1234'],
+};
+
+export interface FakeCubeServiceCatalog {
+  readonly catalog: CubeServiceCatalog;
+  readonly listServices: jest.Mock<CubeServiceCatalog['listServices']>;
+}
+
+/** A fresh fake: build one per test, since jest.fn keeps its calls across tests */
+export const createFakeCubeServiceCatalog = (
+  services: readonly CubeServiceSummary[] = [
+    FAKE_DESKS_SERVICE,
+    FAKE_TRADES_SERVICE,
+  ],
+): FakeCubeServiceCatalog => {
+  const listServices = jest.fn<CubeServiceCatalog['listServices']>(async () =>
+    Promise.resolve(services),
+  );
+  return { catalog: { listServices }, listServices };
+};

package/src/components/CubeAddItems.tsx

@@ -28,10 +28,15 @@ import {
 import type { AnyNodeDefinition } from '@finos/legend-cube';
 import { observer } from 'mobx-react-lite';
 import {
+  getCubeNodeBadge,
   OTHER_SOURCE_KIND_TITLE,
   READ_ONLY_CUBE_TITLE,
 } from '../__lib__/LegendCubeLabels.js';
-import { addCubeNode, canAddCubeNode } from '../stores/CubeAddPlacement.js';
+import {
+  addCubeNode,
+  canAddCubeNode,
+  getCubeAddDatabaseProblem,
+} from '../stores/CubeAddPlacement.js';
 import type { CubeEditorState } from '../stores/CubeEditorState.js';
 import { CubeNodeIcon } from './CubeNodeIcon.js';
 
@@ -40,7 +45,7 @@ interface CubeAddItem {
   readonly definition: AnyNodeDefinition;
   readonly label: string;
   readonly disabled: boolean;
-  /** Why a source can't be added */
+  /** Why a source, or a transform its database can't run, can't be added */
   readonly title: string | undefined;
   readonly add: () => void;
 }
@@ -59,14 +64,16 @@ const getCubeAddItems = (
 ): { sources: CubeAddItem[]; transforms: CubeAddItem[] } => {
   const item = (definition: AnyNodeDefinition): CubeAddItem => {
     const disabled = !canAddCubeNode(editorState, definition.type, nodeId);
+    const badge = getCubeNodeBadge(definition);
     return {
       definition,
-      label: `${definition.label}${definition.beta ? ' (BETA)' : ''}`,
+      label: `${definition.label}${badge ? ` (${badge})` : ''}`,
       disabled,
-      title:
-        disabled && definition.kind === 'source'
+      title: !disabled
+        ? undefined
+        : definition.kind === 'source'
           ? (editorState.sourcePicker.disabledReason ?? OTHER_SOURCE_KIND_TITLE)
-          : undefined,
+          : getCubeAddDatabaseProblem(editorState, definition.type, nodeId),
       add: () => addCubeNode(editorState, definition.type, nodeId),
     };
   };

package/src/components/CubeDialogTheme.ts

@@ -0,0 +1,25 @@
+/**
+ * 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.
+ */
+
+/**
+ * The `darkMode` Cube's dialogs give their primary footer button (Add,
+ * Apply, Close): always legend-art's "dark" variant, which its styles now
+ * draw from the theme's tokens in every theme, an accent button. In a light
+ * theme, its "light" variant, a legacy alias, draws it grey, so an enabled
+ * Add looked disabled. The dialog and its secondary buttons keep following
+ * the theme: the "dark" variant would draw the title dark on the blue header
+ */
+export const CUBE_PRIMARY_BUTTON_DARK_MODE = true;