@finos/legend-application-studio 28.21.51 → 28.21.53

package/src/stores/editor/embedded-cube/EmbeddedCubeState.ts

@@ -0,0 +1,284 @@
+/**
+ * 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 {
+  MILESTONE_INGEST_COLUMNS,
+  type IngestDefinition,
+} from '@finos/legend-graph';
+import type { PlainObject } from '@finos/legend-shared';
+import { action, computed, flowResult, makeObservable, observable } from 'mobx';
+import {
+  getIngestDataSetNames,
+  getIngestMaterializedViews,
+  ingestDefinition_addMaterializedView,
+  ingestDefinition_updateMaterializedView,
+  type IngestMaterializedView,
+  type IngestMaterializedViewOptions,
+} from '../../graph-modifier/DSL_Ingest_GraphModifierHelper.js';
+import type { EditorStore } from '../EditorStore.js';
+import { IngestDefinitionEditorState } from '../editor-state/element-editor-state/ingest/IngestDefinitionEditorState.js';
+
+/** A data set's name: a letter or an underscore, then letters, digits and underscores */
+const DATA_SET_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/u;
+
+/**
+ * The columns a batch-milestoned data set's write mode adds, `LAKE_IN_ID`,
+ * `LAKE_DIGEST` and the like, which a materialized view's primary key leaves
+ * out
+ */
+const MILESTONING_COLUMNS: readonly string[] = Object.values(
+  MILESTONE_INGEST_COLUMNS,
+);
+
+/**
+ * Legend Cube, opened full screen from an ingest definition's editor to build
+ * a materialized view of it from the project's ingest data sets (Create
+ * MatView). Studio's own shortcuts are off while it is open. Cube
+ * itself, and its host, are loaded with the dialog (`EmbeddedCube`), so
+ * nothing here imports them.
+ */
+export class EmbeddedCubeState {
+  readonly editorStore: EditorStore;
+  /** The definition the materialized view is added to; none while closed */
+  ingest: IngestDefinition | undefined;
+  /**
+   * The materialized view opened to edit (Edit MatView, PLAN §11.18), by
+   * name: Cube opens on its lambda, and Save MatView replaces it; none for a
+   * new one
+   */
+  matView: string | undefined;
+
+  constructor(editorStore: EditorStore) {
+    makeObservable(this, {
+      ingest: observable.ref,
+      matView: observable,
+      matViewDataSet: computed,
+      matViewLambda: computed,
+      open: action,
+      close: action,
+      addMaterializedView: action,
+      saveMaterializedView: action,
+    });
+    this.editorStore = editorStore;
+  }
+
+  get isOpen(): boolean {
+    return this.ingest !== undefined;
+  }
+
+  /** Opens Cube on a new materialized view of the definition, or on one of its views to edit */
+  open(ingest: IngestDefinition, matView?: string): void {
+    this.ingest = ingest;
+    this.matView = matView;
+  }
+
+  close(): void {
+    this.ingest = undefined;
+    this.matView = undefined;
+  }
+
+  /** The materialized view opened to edit, as the definition holds it */
+  get matViewDataSet(): IngestMaterializedView | undefined {
+    const { ingest, matView } = this;
+    return ingest && matView !== undefined
+      ? getIngestMaterializedViews(ingest).find((view) => view.name === matView)
+      : undefined;
+  }
+
+  /** The lambda (protocol JSON) of the materialized view opened to edit */
+  get matViewLambda(): PlainObject | undefined {
+    return this.matViewDataSet?.lambda;
+  }
+
+  /** Why the name can't be the new materialized view's; none when it can */
+  getMaterializedViewNameProblem(name: string): string | undefined {
+    const trimmed = name.trim();
+    if (!trimmed) {
+      return 'Name the materialized view.';
+    }
+    if (!DATA_SET_NAME_PATTERN.test(trimmed)) {
+      return 'A data set name is letters, digits and underscores, and starts with a letter or an underscore.';
+    }
+    return this.ingest && getIngestDataSetNames(this.ingest).includes(trimmed)
+      ? `The ingest definition already has a data set named ${trimmed}.`
+      : undefined;
+  }
+
+  /**
+   * The classifications a materialized view's data can take: those a data
+   * product's access points offer; none when Studio's config gives none,
+   * and the classification is then typed
+   */
+  get classifications(): string[] {
+    return (
+      this.editorStore.applicationStore.config.options.dataProductConfig
+        ?.classifications ?? []
+    );
+  }
+
+  /** Why the classification can't be the new materialized view's; none when it can */
+  getMaterializedViewClassificationProblem(
+    sensitivity: string,
+  ): string | undefined {
+    const trimmed = sensitivity.trim();
+    if (!trimmed) {
+      return "Classify the materialized view's data.";
+    }
+    const { classifications } = this;
+    return classifications.length && !classifications.includes(trimmed)
+      ? `${trimmed} isn't one of the data classifications.`
+      : undefined;
+  }
+
+  /**
+   * The columns of the step that runs a materialized view's primary key can
+   * take: all but the milestoning columns a write mode adds
+   */
+  getMaterializedViewKeyColumns(columns: readonly string[]): string[] {
+    return columns.filter((column) => !MILESTONING_COLUMNS.includes(column));
+  }
+
+  /**
+   * Adds the lambda to the ingest definition as a materialized view, with
+   * its primary key and the classification of its data, closes the cube and
+   * shows the definition with it
+   */
+  addMaterializedView(
+    name: string,
+    lambda: PlainObject,
+    options: IngestMaterializedViewOptions,
+  ): void {
+    const { ingest } = this;
+    if (
+      !ingest ||
+      this.getMaterializedViewNameProblem(name) !== undefined ||
+      this.getMaterializedViewClassificationProblem(options.sensitivity) !==
+        undefined
+    ) {
+      return;
+    }
+    ingestDefinition_addMaterializedView(ingest, name.trim(), lambda, {
+      primaryKey: options.primaryKey,
+      sensitivity: options.sensitivity.trim(),
+    });
+    this.closeOn(
+      ingest,
+      `Added materialized view ${name.trim()} to ${ingest.name}`,
+    );
+  }
+
+  /**
+   * Why Save MatView must ask again before it replaces the view opened to
+   * edit with the step that runs, given the step's columns (unknown, the key
+   * isn't checked): its data has no classification, as Studio wrote a view
+   * before it asked for one, or one that isn't among the classifications; or
+   * its primary key has a column the step no longer has, or a milestoning
+   * column. None when the view can be saved as it is
+   */
+  getMaterializedViewSaveProblems(
+    columns: readonly string[] | undefined,
+  ): string[] {
+    const view = this.matViewDataSet;
+    if (!view) {
+      return [];
+    }
+    const problems: string[] = [];
+    const classificationProblem =
+      view.sensitivity === undefined
+        ? `${view.name} has no classification of its data.`
+        : this.getMaterializedViewClassificationProblem(view.sensitivity);
+    if (classificationProblem !== undefined) {
+      problems.push(classificationProblem);
+    }
+    const milestoning = view.primaryKey.filter((column) =>
+      MILESTONING_COLUMNS.includes(column),
+    );
+    const gone = columns
+      ? view.primaryKey.filter(
+          (column) =>
+            !columns.includes(column) && !milestoning.includes(column),
+        )
+      : [];
+    if (gone.length) {
+      problems.push(
+        gone.length === 1
+          ? `Its primary key's ${gone.join(', ')} is no longer a column of the cube.`
+          : `Its primary key's ${gone.join(', ')} are no longer columns of the cube.`,
+      );
+    }
+    if (milestoning.length) {
+      problems.push(
+        milestoning.length === 1
+          ? `Its primary key's ${milestoning.join(', ')} is a milestoning column, which a key leaves out.`
+          : `Its primary key's ${milestoning.join(', ')} are milestoning columns, which a key leaves out.`,
+      );
+    }
+    return problems;
+  }
+
+  /**
+   * Replaces the lambda of the materialized view opened to edit, in place
+   * (Save MatView), with the primary key and classification given, or its
+   * own; closes the cube and shows the definition with it. As a view added,
+   * a view saved has a classification of its data
+   */
+  saveMaterializedView(
+    lambda: PlainObject,
+    options?: IngestMaterializedViewOptions,
+  ): void {
+    const { ingest, matView, matViewDataSet } = this;
+    if (
+      !ingest ||
+      matView === undefined ||
+      !matViewDataSet ||
+      this.getMaterializedViewClassificationProblem(
+        (options ? options.sensitivity : matViewDataSet.sensitivity) ?? '',
+      ) !== undefined
+    ) {
+      return;
+    }
+    ingestDefinition_updateMaterializedView(
+      ingest,
+      matView,
+      lambda,
+      options && {
+        primaryKey: options.primaryKey,
+        sensitivity: options.sensitivity.trim(),
+      },
+    );
+    this.closeOn(
+      ingest,
+      `Saved materialized view ${matView} of ${ingest.name}`,
+    );
+  }
+
+  /** Closes the cube, then shows the definition's grammar with the change */
+  private closeOn(ingest: IngestDefinition, message: string): void {
+    this.close();
+    const editorState = this.editorStore.tabManagerState.tabs.find(
+      (tab): tab is IngestDefinitionEditorState =>
+        tab instanceof IngestDefinitionEditorState && tab.ingest === ingest,
+    );
+    if (editorState) {
+      flowResult(editorState.generateElementGrammar()).catch(
+        this.editorStore.applicationStore.alertUnhandledError,
+      );
+    }
+    this.editorStore.applicationStore.notificationService.notifySuccess(
+      message,
+    );
+  }
+}

package/src/stores/editor/embedded-cube/LegendStudioCubeDataProductCatalog.ts

@@ -0,0 +1,242 @@
+/**
+ * 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 {
+  dataProductAccessor,
+  lambda,
+  type IR,
+  type ModelContext,
+  type Schema,
+} from '@finos/legend-cube';
+import {
+  createCubeDataProductModel,
+  CubeAccessPoint,
+  CubeAccessPointGroup,
+  CubeDataProductCandidate,
+  CubeDataProductDescription,
+  CubeDataProductEnvironmentType,
+  CubeEngineError,
+  CubeEngineErrorKind,
+  type CubeAccessPointLocation,
+  type CubeDataProductCatalog,
+  type CubeDataProductProject,
+  type CubeEngine,
+  type NodeId,
+} from '@finos/legend-cube-builder';
+import { LakehouseAccessPoint, type DataProduct } from '@finos/legend-graph';
+import type { EditorStore } from '../EditorStore.js';
+import {
+  LEGEND_STUDIO_CUBE_WORKSPACE_VERSION,
+  type LegendStudioCubeWorkspace,
+} from './LegendStudioCubeWorkspace.js';
+
+// Legend Cube in Studio: a cube reads the data products of the project being
+// edited, as the workspace holds them, never the platform's deployed ones.
+// Their lakehouse access points are typed by Cube's engine on the workspace,
+// as Studio types them for its own queries, and run on the project's
+// lakehouse runtime.
+
+/** The one class a Studio cube reads the project's data products as, so the tab offers no other */
+const STUDIO_CUBE_DATA_PRODUCT_CLASS =
+  CubeDataProductEnvironmentType.PRODUCTION;
+
+/** The deployment a workspace data product is picked from: none yet */
+const NO_DEPLOYMENT_ID = '0';
+
+export const LEGEND_STUDIO_CUBE_DATA_PRODUCT_MESSAGE = {
+  GONE: (dataProduct: string): string =>
+    `The project has no data product ${dataProduct} any more.`,
+  NOT_LAKEHOUSE: 'Cube reads lakehouse access points only',
+  NO_ACCESS_POINT: (accessPoint: string, dataProduct: string): string =>
+    `Data product ${dataProduct} has no lakehouse access point "${accessPoint}".`,
+};
+
+const keyOf = (group: string, accessPoint: string): string =>
+  `${group}\u0000${accessPoint}`;
+
+/** The lambda that types an access point: `{| #P{dataProduct.accessPoint}#}` */
+const typingLambdaOf = (dataProduct: string, accessPoint: string): IR =>
+  lambda([], [dataProductAccessor([dataProduct, accessPoint])]);
+
+/**
+ * The project's own data products, for the Data Product tab and for
+ * re-checking saved sources. Their access points are typed by the engine, a
+ * product's in one call, on the workspace
+ */
+export class LegendStudioCubeDataProductCatalog
+  implements CubeDataProductCatalog
+{
+  readonly environmentTypes = [STUDIO_CUBE_DATA_PRODUCT_CLASS];
+  readonly editorStore: EditorStore;
+  readonly workspace: LegendStudioCubeWorkspace;
+  private readonly engine: CubeEngine;
+
+  constructor(
+    editorStore: EditorStore,
+    workspace: LegendStudioCubeWorkspace,
+    engine: CubeEngine,
+  ) {
+    this.editorStore = editorStore;
+    this.workspace = workspace;
+    this.engine = engine;
+  }
+
+  /** The project's own data products, not its dependencies' */
+  private get dataProducts(): DataProduct[] {
+    return this.editorStore.graphManagerState.graph.ownDataProducts;
+  }
+
+  /** The model a cube of the workspace's data products names */
+  private get model(): ModelContext {
+    return createCubeDataProductModel({
+      ...this.workspace.project,
+      versionId: LEGEND_STUDIO_CUBE_WORKSPACE_VERSION,
+      environmentType: STUDIO_CUBE_DATA_PRODUCT_CLASS,
+    });
+  }
+
+  private candidateOf(dataProduct: DataProduct): CubeDataProductCandidate {
+    return new CubeDataProductCandidate({
+      id: dataProduct.path,
+      deploymentId: NO_DEPLOYMENT_ID,
+      dataProductPath: dataProduct.path,
+      title: dataProduct.title ?? dataProduct.name,
+      description: dataProduct.description,
+      ...this.workspace.project,
+      versionId: LEGEND_STUDIO_CUBE_WORKSPACE_VERSION,
+      environmentType: STUDIO_CUBE_DATA_PRODUCT_CLASS,
+    });
+  }
+
+  private dataProductOf(path: string): DataProduct {
+    const dataProduct = this.dataProducts.find((each) => each.path === path);
+    if (!dataProduct) {
+      throw new CubeEngineError(
+        CubeEngineErrorKind.COMPILE,
+        LEGEND_STUDIO_CUBE_DATA_PRODUCT_MESSAGE.GONE(path),
+      );
+    }
+    return dataProduct;
+  }
+
+  /** Every data product of the project; the tab matches the text itself */
+  async search(): Promise<readonly CubeDataProductCandidate[]> {
+    return this.dataProducts.map((each) => this.candidateOf(each));
+  }
+
+  /** A product's access point groups, its lakehouse access points typed on the workspace */
+  async describe(
+    candidate: CubeDataProductCandidate,
+  ): Promise<CubeDataProductDescription> {
+    const dataProduct = this.dataProductOf(candidate.dataProductPath);
+    const lambdas = new Map<NodeId, IR>();
+    dataProduct.accessPointGroups.forEach((group) =>
+      group.accessPoints
+        .filter((point) => point instanceof LakehouseAccessPoint)
+        .forEach((point) =>
+          lambdas.set(
+            keyOf(group.id, point.id),
+            typingLambdaOf(dataProduct.path, point.id),
+          ),
+        ),
+    );
+    const schemas = lambdas.size
+      ? await this.engine.typeLambdas(this.model, lambdas)
+      : new Map<NodeId, Schema | CubeEngineError>();
+    return new CubeDataProductDescription(
+      candidate,
+      dataProduct.accessPointGroups
+        .filter((group) => group.accessPoints.length > 0)
+        .map(
+          (group) =>
+            new CubeAccessPointGroup({
+              id: group.id,
+              title: group.title,
+              accessPoints: group.accessPoints.map((point) => {
+                const typed = schemas.get(keyOf(group.id, point.id));
+                return new CubeAccessPoint({
+                  id: point.id,
+                  title: point.title,
+                  description: point.description,
+                  schema: typed instanceof CubeEngineError ? undefined : typed,
+                  disabledReason:
+                    point instanceof LakehouseAccessPoint
+                      ? typed instanceof CubeEngineError
+                        ? typed.firstLine
+                        : undefined
+                      : LEGEND_STUDIO_CUBE_DATA_PRODUCT_MESSAGE.NOT_LAKEHOUSE,
+                });
+              }),
+            }),
+        ),
+    );
+  }
+
+  /** The saved sources' schemas, typed on the workspace in one call */
+  async resolveSchemas(
+    project: CubeDataProductProject,
+    sources: ReadonlyMap<NodeId, CubeAccessPointLocation>,
+  ): Promise<Map<NodeId, Schema | CubeEngineError>> {
+    const resolved = new Map<NodeId, Schema | CubeEngineError>();
+    const lambdas = new Map<NodeId, IR>();
+    sources.forEach((source, nodeId) => {
+      const point = this.dataProducts
+        .find((each) => each.path === source.dataProduct)
+        ?.accessPointGroups.find(
+          (group) => group.id === source.accessPointGroup,
+        )
+        ?.accessPoints.find((each) => each.id === source.accessPoint);
+      if (point instanceof LakehouseAccessPoint) {
+        lambdas.set(
+          nodeId,
+          typingLambdaOf(source.dataProduct, source.accessPoint),
+        );
+      } else {
+        resolved.set(
+          nodeId,
+          new CubeEngineError(
+            CubeEngineErrorKind.COMPILE,
+            LEGEND_STUDIO_CUBE_DATA_PRODUCT_MESSAGE.NO_ACCESS_POINT(
+              source.accessPoint,
+              source.dataProduct,
+            ),
+            nodeId,
+          ),
+        );
+      }
+    });
+    if (lambdas.size) {
+      (
+        await this.engine.typeLambdas(
+          createCubeDataProductModel(project),
+          lambdas,
+        )
+      ).forEach((schema, nodeId) => resolved.set(nodeId, schema));
+    }
+    // in the order the sources were given
+    return new Map(
+      [...sources.keys()].map((nodeId) => [
+        nodeId,
+        resolved.get(nodeId) as Schema | CubeEngineError,
+      ]),
+    );
+  }
+
+  /** No marketplace: a workspace data product has no page there yet */
+  getMarketplaceLink(): string | undefined {
+    return undefined;
+  }
+}

package/src/stores/editor/embedded-cube/LegendStudioCubeHost.ts

@@ -0,0 +1,82 @@
+/**
+ * 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 {
+  buildCubeEngine,
+  LocalModelCatalog,
+  type CubeEngine,
+  type CubeHost,
+} from '@finos/legend-cube-builder';
+import type { LegendStudioApplicationStore } from '../../LegendStudioBaseStore.js';
+import type { EditorStore } from '../EditorStore.js';
+import { LegendStudioCubeDataProductCatalog } from './LegendStudioCubeDataProductCatalog.js';
+import { LegendStudioCubeIngestCatalog } from './LegendStudioCubeIngestCatalog.js';
+import { LegendStudioCubeWorkspace } from './LegendStudioCubeWorkspace.js';
+
+/**
+ * Studio as the host of Legend Cube: Studio's engine and application store,
+ * and the project's own ingest definitions and data products as the only
+ * sources, typed and run on the workspace and the project's lakehouse
+ * runtime. No sample data, examples, databases or services. One per opening
+ * of the cube.
+ */
+export class LegendStudioCubeHost implements CubeHost {
+  readonly applicationStore: LegendStudioApplicationStore;
+  readonly engine: CubeEngine;
+  readonly modelCatalog: LocalModelCatalog;
+  readonly project: LegendStudioCubeWorkspace;
+  readonly ingestCatalog: LegendStudioCubeIngestCatalog;
+  readonly dataProductCatalog: LegendStudioCubeDataProductCatalog;
+  readonly offersSampleData = false;
+
+  constructor(editorStore: EditorStore) {
+    const { applicationStore } = editorStore;
+    const { config } = applicationStore;
+    this.applicationStore = applicationStore;
+    this.project = new LegendStudioCubeWorkspace(editorStore);
+    this.ingestCatalog = new LegendStudioCubeIngestCatalog(
+      editorStore,
+      this.project,
+    );
+    // the engine Studio's own editor uses, configured the same way; a run
+    // reads the workspace, and names the project's lakehouse environment
+    this.engine = buildCubeEngine(
+      {
+        baseUrl:
+          editorStore.editorConfig?.engineServerUrl ?? config.engineServerUrl,
+        queryBaseUrl:
+          editorStore.editorConfig?.engineQueryServerUrl ??
+          config.engineQueryServerUrl,
+        queryClientName: config.engineQueryClientName,
+        enableCompression: true,
+        useCookieAuthOnly: config.engineUseCookieAuthOnly,
+      },
+      applicationStore.tracerService,
+      {
+        ingestCatalog: this.ingestCatalog,
+        ingestDefinitionSource: this.ingestCatalog,
+        lakehouseEnvironment: this.project,
+        dataProductModelSource: this.project,
+      },
+    );
+    this.dataProductCatalog = new LegendStudioCubeDataProductCatalog(
+      editorStore,
+      this.project,
+      this.engine,
+    );
+    this.modelCatalog = new LocalModelCatalog(this.engine);
+  }
+}