@finos/legend-cube-builder 0.0.3 → 0.0.4

package/src/stores/source-picker/CubeInlineModelTabState.ts

@@ -0,0 +1,448 @@
+/**
+ * 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 {
+  type CubeContext,
+  getRelationalDisplayName,
+  type ModelContext,
+  RELATIONAL_TABLE_SOURCE_DEFINITION,
+  RelationalTableSource,
+} from '@finos/legend-cube';
+import { assertErrorThrown, type GeneratorFn } from '@finos/legend-shared';
+import {
+  action,
+  computed,
+  flow,
+  flowResult,
+  makeObservable,
+  observable,
+} from 'mobx';
+import {
+  CubeEngineError,
+  CubeEngineErrorKind,
+  CubeTableFlag,
+  type CubeModelOutline,
+  type CubeOutlineDatabase,
+  type CubeOutlineRuntime,
+  type CubeOutlineSchema,
+  type CubeOutlineTable,
+} from '../../graph-manager/CubeEngine.js';
+import { getRuntimesForDatabase } from '../../graph-manager/CubeModelOutlineHelper.js';
+import type { CubeEditorState } from '../CubeEditorState.js';
+import { loadCubeModelOutline } from '../CubeHost.js';
+import { type BundledModel, createTextModel } from '../LocalModelCatalog.js';
+import {
+  type CubeSourcePickerTab,
+  CubeSourcePickerTabKey,
+} from './CubeSourcePickerTab.js';
+
+const toMessage = (error: unknown): string => {
+  assertErrorThrown(error);
+  return error instanceof CubeEngineError ? error.firstLine : error.message;
+};
+
+/** Whether a table can be picked: a table with a column Cube can't read can't */
+export const isTableSelectable = (table: CubeOutlineTable): boolean =>
+  !table.flags.includes(CubeTableFlag.UNAVAILABLE);
+
+/**
+ * The source picker's Model tab (PLAN §6.2.7, Settled before M1.8): model,
+ * then database, then a runtime keyed by that database, then schema and
+ * table. A step with a single choice is picked automatically. The first
+ * table fixes the cube's model and runtime; later tables come from the same
+ * database and runtime. A table is added only once its schema has resolved.
+ * It serves every cube no other tab claims, e.g. one on Pure text.
+ */
+export class CubeInlineModelTabState implements CubeSourcePickerTab {
+  readonly key: CubeSourcePickerTabKey = CubeSourcePickerTabKey.MODEL;
+  readonly label: string = 'Sample Data';
+  readonly editorState: CubeEditorState;
+
+  model: ModelContext | undefined;
+  /** The model is Pure text the user pastes, not a bundled one */
+  isPastingModel = false;
+  pastedModelText = '';
+  /** The model the paste box last loaded: only it keeps the box shown */
+  private pastedModel: ModelContext | undefined;
+  outline: CubeModelOutline | undefined;
+  isLoadingModel = false;
+  databasePath: string | undefined;
+  runtimePath: string | undefined;
+  schemaName: string | undefined;
+  tableName: string | undefined;
+  tableSearch = '';
+  isResolving = false;
+  /** Why the outline or the table couldn't be loaded, shown in the dialog */
+  error: string | undefined;
+  /** Counts Add presses: closing the dialog moves it on, so the pending Add is dropped */
+  private confirmRequest = 0;
+
+  constructor(editorState: CubeEditorState) {
+    makeObservable(this, {
+      model: observable.ref,
+      isPastingModel: observable,
+      pastedModelText: observable,
+      outline: observable.ref,
+      isLoadingModel: observable,
+      databasePath: observable,
+      runtimePath: observable,
+      schemaName: observable,
+      tableName: observable,
+      tableSearch: observable,
+      isResolving: observable,
+      error: observable,
+      fixedContext: computed,
+      fixedDatabasePath: computed,
+      databases: computed,
+      runtimes: computed,
+      schemas: computed,
+      tables: computed,
+      canConfirm: computed,
+      isBusy: computed,
+      open: action,
+      close: action,
+      selectDatabase: action,
+      selectRuntime: action,
+      selectSchema: action,
+      selectTable: action,
+      setTableSearch: action,
+      startPastingModel: action,
+      setPastedModelText: action,
+      selectModel: flow,
+      loadPastedModel: flow,
+      confirm: flow,
+    });
+    this.editorState = editorState;
+  }
+
+  get models(): readonly BundledModel[] {
+    return this.editorState.host.modelCatalog.models;
+  }
+
+  /** Once the cube has a model, every table comes from it */
+  get fixedContext(): CubeContext | undefined {
+    return this.editorState.document.context;
+  }
+
+  /** Once the cube has a table, every other one comes from its database */
+  get fixedDatabasePath(): string | undefined {
+    return this.editorState.document.query.nodes.find(
+      (node): node is RelationalTableSource =>
+        node instanceof RelationalTableSource,
+    )?.database;
+  }
+
+  get databases(): readonly CubeOutlineDatabase[] {
+    const databases = this.outline?.databases ?? [];
+    const fixedRuntime = this.fixedContext?.runtime;
+    return databases.filter(
+      (database) =>
+        (this.fixedDatabasePath === undefined ||
+          database.path === this.fixedDatabasePath) &&
+        (fixedRuntime === undefined ||
+          (this.outline &&
+            getRuntimesForDatabase(this.outline, database.path).some(
+              (runtime) => runtime.path === fixedRuntime,
+            ))),
+    );
+  }
+
+  get runtimes(): readonly CubeOutlineRuntime[] {
+    if (!this.outline || this.databasePath === undefined) {
+      return [];
+    }
+    const fixedRuntime = this.fixedContext?.runtime;
+    return getRuntimesForDatabase(this.outline, this.databasePath).filter(
+      (runtime) => fixedRuntime === undefined || runtime.path === fixedRuntime,
+    );
+  }
+
+  get schemas(): readonly CubeOutlineSchema[] {
+    return (
+      this.databases.find((database) => database.path === this.databasePath)
+        ?.schemas ?? []
+    );
+  }
+
+  /** The schema's tables, views left out, filtered by the search text */
+  get tables(): readonly CubeOutlineTable[] {
+    const search = this.tableSearch.trim().toLowerCase();
+    return (
+      this.schemas.find((schema) => schema.name === this.schemaName)?.tables ??
+      []
+    ).filter(
+      (table) =>
+        !table.isView &&
+        getRelationalDisplayName(table.name).toLowerCase().includes(search),
+    );
+  }
+
+  /** The host serves the tab: it always serves models */
+  get isAvailable(): boolean {
+    return true;
+  }
+
+  get isBusy(): boolean {
+    return this.isLoadingModel || this.isResolving;
+  }
+
+  /** The tab claims no cube: the dialog gives it every cube no other tab claims */
+  ownsContext(context: CubeContext): boolean {
+    return false;
+  }
+
+  get canConfirm(): boolean {
+    const table = this.tables.find(
+      (candidate) => candidate.name === this.tableName,
+    );
+    return (
+      !this.isLoadingModel &&
+      !this.isResolving &&
+      this.model !== undefined &&
+      this.runtimePath !== undefined &&
+      table !== undefined &&
+      isTableSelectable(table)
+    );
+  }
+
+  /**
+   * When the dialog opens on the tab: on the cube's model, else the pasted
+   * model while the paste box is shown, else the bundled model picked last,
+   * else the first one. A model whose outline failed to load is loaded again.
+   */
+  open(): void {
+    this.error = undefined;
+    const model =
+      this.fixedContext?.model ??
+      (this.isPastingModel
+        ? this.model
+        : (
+            this.models.find((bundled) => bundled.model === this.model) ??
+            this.models[0]
+          )?.model);
+    if (!model) {
+      return;
+    }
+    if (model !== this.model || !this.outline) {
+      flowResult(this.selectModel(model)).catch(
+        this.editorState.host.applicationStore.alertUnhandledError,
+      );
+    } else if (
+      this.databasePath !== undefined &&
+      !this.databases.some((database) => database.path === this.databasePath)
+    ) {
+      // the cube changed since the last pick, e.g. by undo
+      const [onlyDatabase, ...otherDatabases] = this.databases;
+      this.selectDatabase(
+        onlyDatabase && !otherDatabases.length ? onlyDatabase.path : undefined,
+      );
+    }
+  }
+
+  /** When the dialog closes: a table still being typed is not added */
+  close(): void {
+    this.confirmRequest++;
+    this.isResolving = false;
+  }
+
+  /** Offers a text box for a Pure model in place of the bundled ones */
+  startPastingModel(): void {
+    this.isPastingModel = true;
+    this.model = undefined;
+    this.outline = undefined;
+    this.error = undefined;
+    this.isLoadingModel = false;
+    this.resetFrom('database');
+  }
+
+  setPastedModelText(text: string): void {
+    this.pastedModelText = text;
+  }
+
+  /**
+   * Loads the pasted Pure text as the model: the cube will hold the text
+   * itself, so it counts towards the size a saved cube can have
+   */
+  *loadPastedModel(): GeneratorFn<void> {
+    if (this.pastedModelText.trim()) {
+      this.pastedModel = createTextModel(this.pastedModelText);
+      yield flowResult(this.selectModel(this.pastedModel));
+    }
+  }
+
+  /**
+   * Loads a model's outline. Any model but the one the paste box loaded ends
+   * pasting, e.g. a bundled model, or the model of a cube opened meanwhile.
+   */
+  *selectModel(model: ModelContext): GeneratorFn<void> {
+    this.isPastingModel = model === this.pastedModel;
+    this.model = model;
+    this.outline = undefined;
+    this.error = undefined;
+    this.resetFrom('database');
+    this.isLoadingModel = true;
+    try {
+      const outline = (yield loadCubeModelOutline(
+        this.editorState.host,
+        model,
+      )) as CubeModelOutline;
+      if (this.model !== model) {
+        return;
+      }
+      this.outline = outline;
+      const [onlyDatabase, ...otherDatabases] = this.databases;
+      if (onlyDatabase && !otherDatabases.length) {
+        this.selectDatabase(onlyDatabase.path);
+      }
+    } catch (error) {
+      if (this.model === model) {
+        this.error = toMessage(error);
+      }
+    } finally {
+      if (this.model === model) {
+        this.isLoadingModel = false;
+      }
+    }
+  }
+
+  selectDatabase(path: string | undefined): void {
+    this.databasePath = path;
+    this.resetFrom('runtime');
+    const [onlyRuntime, ...otherRuntimes] = this.runtimes;
+    if (onlyRuntime && !otherRuntimes.length) {
+      this.runtimePath = onlyRuntime.path;
+    }
+    const [onlySchema, ...otherSchemas] = this.schemas;
+    if (onlySchema && !otherSchemas.length) {
+      this.schemaName = onlySchema.name;
+    }
+  }
+
+  selectRuntime(path: string | undefined): void {
+    this.runtimePath = path;
+  }
+
+  selectSchema(name: string | undefined): void {
+    this.schemaName = name;
+    this.resetFrom('table');
+  }
+
+  selectTable(name: string | undefined): void {
+    this.tableName = name;
+    this.error = undefined;
+  }
+
+  setTableSearch(search: string): void {
+    this.tableSearch = search;
+  }
+
+  /**
+   * Types the picked table with the engine, then adds it; the first table
+   * also sets the cube's model and runtime, in the same undo step. The cube
+   * may have changed while the engine answered: the table is added only if
+   * the cube still has the same model and runtime and can take it. Gives
+   * whether the table was added.
+   */
+  *confirm(): GeneratorFn<boolean> {
+    if (!this.canConfirm) {
+      return false;
+    }
+    const { editorState } = this;
+    const model = this.model as ModelContext;
+    const runtime = this.runtimePath as string;
+    const coordinates = {
+      database: this.databasePath as string,
+      schema: this.schemaName as string,
+      table: this.tableName as string,
+    };
+    const contextBefore = editorState.document.context;
+    // the engine stamps the table's accessor with its node id, so the id comes first
+    const id = editorState.document.query.generateId(
+      RelationalTableSource.TYPE,
+    );
+    const request = ++this.confirmRequest;
+    this.isResolving = true;
+    this.error = undefined;
+    try {
+      const typed = (yield editorState.host.engine.resolveSchemas(
+        model,
+        new Map([
+          [id, [coordinates.database, coordinates.schema, coordinates.table]],
+        ]),
+      )) as Awaited<ReturnType<typeof editorState.host.engine.resolveSchemas>>;
+      if (request !== this.confirmRequest) {
+        return false;
+      }
+      const schema = typed.get(id);
+      if (schema === undefined || schema instanceof CubeEngineError) {
+        throw (
+          schema ??
+          new CubeEngineError(
+            CubeEngineErrorKind.COMPILE,
+            `The engine gave no schema for this table`,
+          )
+        );
+      }
+      const node = RELATIONAL_TABLE_SOURCE_DEFINITION.resolve(
+        RELATIONAL_TABLE_SOURCE_DEFINITION.fromCoordinates(id, coordinates),
+        { kind: 'resolved', schema },
+      );
+      const { document } = editorState;
+      if (document.context !== contextBefore || !document.query.canAdd(node)) {
+        throw new Error(
+          `The cube changed while the table was loading; pick the table again.`,
+        );
+      }
+      const query = document.query.add(node);
+      // the first table sets the model and runtime; a cube saved with a model
+      // but no runtime takes the picked runtime and keeps the rest
+      editorState.applyDocument(
+        document.context?.runtime !== undefined
+          ? document.withQuery(query)
+          : document
+              .withContext({
+                ...document.context,
+                model: document.context?.model ?? model,
+                runtime,
+              })
+              .withQuery(query),
+      );
+      this.resetFrom('table');
+      return true;
+    } catch (error) {
+      if (request === this.confirmRequest) {
+        this.error = toMessage(error);
+      }
+      return false;
+    } finally {
+      if (request === this.confirmRequest) {
+        this.isResolving = false;
+      }
+    }
+  }
+
+  protected resetFrom(step: 'database' | 'runtime' | 'table'): void {
+    if (step === 'database') {
+      this.databasePath = undefined;
+    }
+    if (step === 'database' || step === 'runtime') {
+      this.runtimePath = undefined;
+      this.schemaName = undefined;
+    }
+    this.tableName = undefined;
+    this.tableSearch = '';
+  }
+}

package/src/stores/source-picker/CubeProjectTabState.ts

@@ -0,0 +1,218 @@
+/**
+ * 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 type { CubeContext } from '@finos/legend-cube';
+import { assertErrorThrown, type GeneratorFn } from '@finos/legend-shared';
+import {
+  action,
+  computed,
+  flow,
+  flowResult,
+  makeObservable,
+  observable,
+  override,
+} from 'mobx';
+import {
+  createCubeProjectModel,
+  getCubeProjectCoordinates,
+  isCubeProjectModel,
+} from '../../graph-manager/CubeProject.js';
+import type { CubeProjectSummary } from '../../graph-manager/CubeProjectCatalog.js';
+import type { CubeEditorState } from '../CubeEditorState.js';
+import { CubeInlineModelTabState } from './CubeInlineModelTabState.js';
+import { CubeSourcePickerTabKey } from './CubeSourcePickerTab.js';
+
+/** A project as the tab keys it: `group:artifact` */
+export const getCubeProjectKey = (project: CubeProjectSummary): string =>
+  `${project.groupId}:${project.artifactId}`;
+
+const toMessage = (error: unknown): string => {
+  assertErrorThrown(error);
+  return error.message;
+};
+
+/**
+ * The source dialog's Project tab (PLAN §6.3): a published project in the
+ * host's depot, one of its released versions (the newest picked), then, as
+ * in the Model tab, one of the project's own Databases, a runtime keyed by
+ * it, a schema and a table. The first table saves the project at that
+ * version as the cube's model; every later table comes from it.
+ */
+export class CubeProjectTabState extends CubeInlineModelTabState {
+  override readonly key = CubeSourcePickerTabKey.PROJECT;
+  override readonly label = 'Project Database';
+
+  projects: readonly CubeProjectSummary[] | undefined;
+  isLoadingProjects = false;
+  projectKey: string | undefined;
+  versions: readonly string[] | undefined;
+  isLoadingVersions = false;
+  versionId: string | undefined;
+  /** Why the projects or versions couldn't be listed */
+  listError: string | undefined;
+
+  constructor(editorState: CubeEditorState) {
+    super(editorState);
+    makeObservable(this, {
+      projects: observable.ref,
+      isLoadingProjects: observable,
+      projectKey: observable,
+      versions: observable.ref,
+      isLoadingVersions: observable,
+      versionId: observable,
+      listError: observable,
+      isBusy: override,
+      fixedProjectKey: computed,
+      open: override,
+      loadProjects: flow,
+      selectProject: flow,
+      selectVersion: action,
+    });
+  }
+
+  override get isAvailable(): boolean {
+    return this.editorState.host.projectCatalog !== undefined;
+  }
+
+  override get isBusy(): boolean {
+    return this.isLoadingProjects || this.isLoadingVersions || super.isBusy;
+  }
+
+  /** A cube on a project model is this tab's, whether or not Cube can run it */
+  override ownsContext(context: CubeContext): boolean {
+    return isCubeProjectModel(context.model);
+  }
+
+  /** The cube's project, fixed by its first table */
+  get fixedProjectKey(): string | undefined {
+    const model = this.fixedContext?.model;
+    const project = model ? getCubeProjectCoordinates(model) : undefined;
+    return project ? getCubeProjectKey(project) : undefined;
+  }
+
+  /**
+   * When the dialog opens on the tab: on the cube's project and version, else
+   * on the project picked last, listing the projects the first time (and
+   * again after a failure)
+   */
+  override open(): void {
+    this.error = undefined;
+    const fixedModel = this.fixedContext?.model;
+    if (fixedModel) {
+      const project = getCubeProjectCoordinates(fixedModel);
+      if (project) {
+        this.projectKey = getCubeProjectKey(project);
+        this.versions = [project.versionId];
+        this.versionId = project.versionId;
+      }
+      if (fixedModel !== this.model || !this.outline) {
+        flowResult(this.selectModel(fixedModel)).catch(
+          this.editorState.host.applicationStore.alertUnhandledError,
+        );
+      }
+      return;
+    }
+    if (this.projects === undefined && !this.isLoadingProjects) {
+      flowResult(this.loadProjects()).catch(
+        this.editorState.host.applicationStore.alertUnhandledError,
+      );
+    }
+  }
+
+  /** Lists the depot's projects; a single one is picked */
+  *loadProjects(): GeneratorFn<void> {
+    const catalog = this.editorState.host.projectCatalog;
+    if (!catalog) {
+      return;
+    }
+    this.isLoadingProjects = true;
+    this.listError = undefined;
+    try {
+      this.projects = (yield catalog.listProjects()) as CubeProjectSummary[];
+      const [onlyProject, ...otherProjects] = this.projects;
+      if (onlyProject && !otherProjects.length) {
+        yield flowResult(this.selectProject(getCubeProjectKey(onlyProject)));
+      }
+    } catch (error) {
+      this.listError = `Can't list the depot's projects: ${toMessage(error)}`;
+    } finally {
+      this.isLoadingProjects = false;
+    }
+  }
+
+  /** Picks a project and lists its released versions, picking the newest */
+  *selectProject(key: string | undefined): GeneratorFn<void> {
+    const catalog = this.editorState.host.projectCatalog;
+    this.projectKey = key;
+    this.versions = undefined;
+    this.versionId = undefined;
+    this.model = undefined;
+    this.outline = undefined;
+    this.error = undefined;
+    this.listError = undefined;
+    this.resetFrom('database');
+    const project = this.projects?.find(
+      (candidate) => getCubeProjectKey(candidate) === key,
+    );
+    if (!catalog || !project) {
+      return;
+    }
+    this.isLoadingVersions = true;
+    try {
+      const versions = (yield catalog.listVersions(project)) as string[];
+      if (this.projectKey !== key) {
+        return;
+      }
+      this.versions = versions;
+      if (!versions.length) {
+        this.listError = `${key} has no released version`;
+        return;
+      }
+      this.selectVersion(versions[0]);
+    } catch (error) {
+      if (this.projectKey === key) {
+        this.listError = `Can't list the versions of ${key}: ${toMessage(error)}`;
+      }
+    } finally {
+      if (this.projectKey === key) {
+        this.isLoadingVersions = false;
+      }
+    }
+  }
+
+  /** Picks a version and loads its Databases and runtimes */
+  selectVersion(versionId: string | undefined): void {
+    this.versionId = versionId;
+    const project = this.projects?.find(
+      (candidate) => getCubeProjectKey(candidate) === this.projectKey,
+    );
+    if (!project || versionId === undefined) {
+      this.model = undefined;
+      this.outline = undefined;
+      this.resetFrom('database');
+      return;
+    }
+    flowResult(
+      this.selectModel(
+        createCubeProjectModel({
+          groupId: project.groupId,
+          artifactId: project.artifactId,
+          versionId,
+        }),
+      ),
+    ).catch(this.editorState.host.applicationStore.alertUnhandledError);
+  }
+}