@finos/legend-cube-builder 0.0.3 → 0.0.5

package/src/stores/CubeSourcePickerState.ts

@@ -15,13 +15,13 @@
  */
 
 import {
-  type CubeContext,
-  getRelationalDisplayName,
-  type ModelContext,
-  RELATIONAL_TABLE_SOURCE_DEFINITION,
+  DataProductAccessPointSource,
+  FunctionSource,
+  IngestDatasetSource,
   RelationalTableSource,
+  ServiceSource,
 } from '@finos/legend-cube';
-import { assertErrorThrown, type GeneratorFn } from '@finos/legend-shared';
+import type { GeneratorFn } from '@finos/legend-shared';
 import {
   action,
   computed,
@@ -31,396 +31,302 @@ import {
   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';
+  READ_ONLY_CUBE_TITLE,
+  UNSERVED_SOURCE_KIND_TITLE,
+} from '../__lib__/LegendCubeLabels.js';
 import type { CubeEditorState } from './CubeEditorState.js';
-import { type BundledModel, createTextModel } from './LocalModelCatalog.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);
+import { CubeDataProductTabState } from './source-picker/CubeDataProductTabState.js';
+import { CubeDirectConnectionTabState } from './source-picker/CubeDirectConnectionTabState.js';
+import { CubeIngestTabState } from './source-picker/CubeIngestTabState.js';
+import {
+  CubeProjectFunctionTabState,
+  CubeProjectTabState,
+} from './source-picker/CubeProjectTabState.js';
+import {
+  CubeInlineModelTabState,
+  CubeModelReadKind,
+} from './source-picker/CubeInlineModelTabState.js';
+import { CubeServiceTabState } from './source-picker/CubeServiceTabState.js';
+import {
+  type CubeSourcePickerTab,
+  CubeSourcePickerTabKey,
+} from './source-picker/CubeSourcePickerTab.js';
 
 /**
- * The source picker (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.
+ * The source dialog (PLAN §6.1, §6.8): a tab per way to find a source, the
+ * Sample Data tab first. It opens on the tab asked for, or the one the cube's
+ * fixed context belongs to, which is then the only tab enabled; Add runs the
+ * open tab's Add and closes the dialog once the source is added.
  */
 export class CubeSourcePickerState {
   readonly editorState: CubeEditorState;
+  readonly modelTab: CubeInlineModelTabState;
+  readonly directTab: CubeDirectConnectionTabState;
+  readonly dataProductTab: CubeDataProductTabState;
+  readonly ingestTab: CubeIngestTabState;
+  readonly projectTab: CubeProjectTabState;
+  readonly projectFunctionTab: CubeProjectFunctionTabState;
+  readonly serviceTab: CubeServiceTabState;
 
   isOpen = false;
-  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;
+  activeTabKey = CubeSourcePickerTabKey.MODEL;
+  /** Open with no tab chosen yet, from the empty canvas's link (U4(b)) */
+  isChoosingTab = false;
+  /** Opened from the Examples dialog's dataset, so it offers a way back to it */
+  isFromExamples = false;
 
   constructor(editorState: CubeEditorState) {
     makeObservable(this, {
       isOpen: observable,
-      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,
+      activeTabKey: observable,
+      isChoosingTab: observable,
+      isFromExamples: observable,
+      tabs: computed,
+      fixedTab: computed,
+      activeTab: computed,
+      disabledReason: computed,
       canConfirm: computed,
       open: action,
+      openToChoose: action,
+      openForSourceType: action,
+      openFromExamples: action,
+      backToExamples: action,
+      selectTab: 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;
+    this.modelTab = new CubeInlineModelTabState(editorState);
+    this.directTab = new CubeDirectConnectionTabState(editorState);
+    this.dataProductTab = new CubeDataProductTabState(editorState);
+    this.ingestTab = new CubeIngestTabState(editorState);
+    this.projectTab = new CubeProjectTabState(editorState);
+    this.projectFunctionTab = new CubeProjectFunctionTabState(editorState);
+    this.serviceTab = new CubeServiceTabState(editorState);
   }
 
-  get models(): readonly BundledModel[] {
-    return this.editorState.host.modelCatalog.models;
+  /** The tabs that add their own kind of source, each from its palette item */
+  private get dedicatedTabs(): ReadonlyMap<string, CubeSourcePickerTab> {
+    return new Map<string, CubeSourcePickerTab>([
+      [DataProductAccessPointSource.TYPE, this.dataProductTab],
+      [IngestDatasetSource.TYPE, this.ingestTab],
+      [ServiceSource.TYPE, this.serviceTab],
+    ]);
   }
 
-  /** Once the cube has a model, every table comes from it */
-  get fixedContext(): CubeContext | undefined {
-    return this.editorState.document.context;
+  /** The tabs the host serves, in order */
+  get tabs(): readonly CubeSourcePickerTab[] {
+    return [
+      this.modelTab,
+      this.projectTab,
+      this.projectFunctionTab,
+      this.directTab,
+      this.dataProductTab,
+      this.ingestTab,
+      this.serviceTab,
+    ].filter((tab) => tab.isAvailable);
   }
 
-  /** 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;
+  /**
+   * The tab the cube's fixed context belongs to, which the host may not
+   * serve; the Sample Data tab takes any context no tab claims
+   */
+  get fixedTab(): CubeSourcePickerTab | undefined {
+    const { context } = this.editorState.document;
+    return context
+      ? ([
+          this.projectTab,
+          this.projectFunctionTab,
+          this.directTab,
+          this.dataProductTab,
+          this.ingestTab,
+          this.serviceTab,
+        ].find((tab) => tab.ownsContext(context)) ?? this.modelTab)
+      : undefined;
   }
 
-  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,
-            ))),
+  /** The tab open last, else the first the host serves */
+  get activeTab(): CubeSourcePickerTab {
+    return (
+      this.tabs.find((tab) => tab.key === this.activeTabKey) ??
+      this.tabs[0] ??
+      this.modelTab
     );
   }
 
-  get runtimes(): readonly CubeOutlineRuntime[] {
-    if (!this.outline || this.databasePath === undefined) {
-      return [];
+  /**
+   * The tab a palette item opens (DP-3): a data product's, an ingest data
+   * set's or a service's own tab, when the host serves it; for a table, the table tab the
+   * cube uses, else the table tab open last, else the Sample Data tab
+   */
+  tabForSourceType(type: string): CubeSourcePickerTab | undefined {
+    const dedicated = this.dedicatedTabs.get(type);
+    if (dedicated) {
+      return dedicated.isAvailable ? dedicated : undefined;
     }
-    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 ?? []
+    if (type !== RelationalTableSource.TYPE && type !== FunctionSource.TYPE) {
+      return undefined;
+    }
+    const dedicatedTabs = [...this.dedicatedTabs.values()];
+    // a table comes from a model or a connection, a function from a model:
+    // a project's tables and functions each have their own tab
+    const readers = this.tabs.filter((tab) =>
+      type === FunctionSource.TYPE
+        ? tab instanceof CubeInlineModelTabState &&
+          tab.readKinds.includes(CubeModelReadKind.FUNCTION)
+        : !dedicatedTabs.includes(tab) &&
+          (!(tab instanceof CubeInlineModelTabState) ||
+            tab.readKinds.includes(CubeModelReadKind.TABLE)),
     );
+    return this.fixedTab
+      ? readers.find((tab) => this.isTabEnabled(tab))
+      : (readers.find((tab) => tab === this.activeTab) ?? readers[0]);
   }
 
-  /** 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),
-    );
+  /**
+   * Opens the dialog on the tab a palette item's type opens; a model's tab
+   * reads tables or functions as the item asks
+   */
+  openForSourceType(type: string): void {
+    const tab = this.tabForSourceType(type);
+    if (tab instanceof CubeInlineModelTabState) {
+      tab.setReadKind(
+        type === FunctionSource.TYPE
+          ? CubeModelReadKind.FUNCTION
+          : CubeModelReadKind.TABLE,
+      );
+    }
+    this.open(tab?.key);
   }
 
-  get canConfirm(): boolean {
-    const table = this.tables.find(
-      (candidate) => candidate.name === this.tableName,
-    );
+  /**
+   * A cube with a fixed context takes sources from its own tab only, and
+   * none when the host doesn't serve that tab; a project cube from both of
+   * its tabs, Project Database and Project Function (PLAN §6.5)
+   */
+  isTabEnabled(tab: CubeSourcePickerTab): boolean {
+    const { fixedTab } = this;
+    const { context } = this.editorState.document;
     return (
-      !this.isLoadingModel &&
-      !this.isResolving &&
-      this.model !== undefined &&
-      this.runtimePath !== undefined &&
-      table !== undefined &&
-      isTableSelectable(table)
+      tab.isAvailable &&
+      (fixedTab === undefined ||
+        tab === fixedTab ||
+        // a project cube's tables and functions, each from its tab
+        (context !== undefined &&
+          tab !== this.modelTab &&
+          tab.ownsContext(context)))
     );
   }
 
   /**
-   * Opens the dialog on the cube's model, or on the only model offered. A
-   * model whose outline failed to load is loaded again. Does nothing while
-   * the cube is read-only.
+   * Why the dialog can't open, else undefined: the cube is read-only, or the
+   * host doesn't serve the cube's kind of source, so no tab could add one
    */
-  open(): void {
+  get disabledReason(): string | undefined {
     if (this.editorState.readOnly) {
-      return;
-    }
-    this.isOpen = true;
-    this.error = undefined;
-    const model =
-      this.fixedContext?.model ??
-      (this.models.length === 1 && !this.isPastingModel
-        ? this.models[0]?.model
-        : this.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,
-      );
+      return READ_ONLY_CUBE_TITLE;
     }
+    const { fixedTab } = this;
+    return fixedTab && !fixedTab.isAvailable
+      ? UNSERVED_SOURCE_KIND_TITLE
+      : undefined;
   }
 
-  /** Closes the dialog; a table still being typed is not added */
-  close(): void {
-    this.isOpen = false;
-    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;
+  get canConfirm(): boolean {
+    return (
+      !this.isChoosingTab &&
+      this.activeTab.canConfirm &&
+      this.isTabEnabled(this.activeTab)
+    );
   }
 
   /**
-   * 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
+   * Opens the dialog on the cube's own tab, else the tab asked for, else the
+   * one open last. Does nothing while it can't open (`disabledReason`).
    */
-  *loadPastedModel(): GeneratorFn<void> {
-    if (this.pastedModelText.trim()) {
-      this.pastedModel = createTextModel(this.pastedModelText);
-      yield flowResult(this.selectModel(this.pastedModel));
+  open(tabKey?: CubeSourcePickerTabKey): void {
+    if (this.disabledReason !== undefined) {
+      return;
     }
+    const { fixedTab } = this;
+    this.isOpen = true;
+    this.isChoosingTab = false;
+    this.isFromExamples = false;
+    const tab =
+      fixedTab ??
+      this.tabs.find((candidate) => candidate.key === tabKey) ??
+      this.activeTab;
+    this.activeTabKey = tab.key;
+    tab.open();
   }
 
   /**
-   * 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.
+   * Opens the dialog with no tab chosen, showing the prompt to choose one
+   * (U4(b)); a cube with a fixed context, or a host serving one tab, opens
+   * on it as `open` does
    */
-  *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 this.editorState.host.modelCatalog.loadOutline(
-        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;
-      }
+  openToChoose(): void {
+    if (this.fixedTab !== undefined || this.tabs.length <= 1) {
+      this.open();
+    } else if (this.disabledReason === undefined) {
+      this.isOpen = true;
+      this.isChoosingTab = true;
     }
   }
 
-  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;
+  /** Switches to an enabled tab; the tab left drops what it was waiting for */
+  selectTab(tabKey: CubeSourcePickerTabKey): void {
+    const tab = this.tabs.find((candidate) => candidate.key === tabKey);
+    if (
+      tab &&
+      this.isTabEnabled(tab) &&
+      (this.isChoosingTab || tab !== this.activeTab)
+    ) {
+      if (!this.isChoosingTab) {
+        this.activeTab.close();
+      }
+      this.isChoosingTab = false;
+      this.activeTabKey = tab.key;
+      tab.open();
     }
   }
 
-  selectRuntime(path: string | undefined): void {
-    this.runtimePath = path;
-  }
-
-  selectSchema(name: string | undefined): void {
-    this.schemaName = name;
-    this.resetFrom('table');
+  /** Opens on a tab, as `open` does, offering a way back to the Examples dialog */
+  openFromExamples(tabKey: CubeSourcePickerTabKey): void {
+    this.open(tabKey);
+    this.isFromExamples = this.isOpen;
   }
 
-  selectTable(name: string | undefined): void {
-    this.tableName = name;
-    this.error = undefined;
+  /** Closes the dialog and reopens the Examples dialog it came from */
+  backToExamples(): void {
+    this.close();
+    this.editorState.examples.open();
   }
 
-  setTableSearch(search: string): void {
-    this.tableSearch = search;
+  /** Closes the dialog; a source still being typed is not added */
+  close(): void {
+    this.isOpen = false;
+    this.isFromExamples = false;
+    this.isChoosingTab = false;
+    this.modelTab.close();
+    this.directTab.close();
+    this.dataProductTab.close();
+    this.ingestTab.close();
+    this.projectTab.close();
+    this.projectFunctionTab.close();
+    this.serviceTab.close();
   }
 
-  /**
-   * 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.
-   */
+  /** Adds the open tab's source, then closes the dialog */
   *confirm(): GeneratorFn<void> {
+    const tab = this.activeTab;
     if (!this.canConfirm) {
       return;
     }
-    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;
-      }
-      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.isOpen = false;
-      this.resetFrom('table');
-    } catch (error) {
-      if (request === this.confirmRequest) {
-        this.error = toMessage(error);
-      }
-    } finally {
-      if (request === this.confirmRequest) {
-        this.isResolving = false;
-      }
-    }
-  }
-
-  private resetFrom(step: 'database' | 'runtime' | 'table'): void {
-    if (step === 'database') {
-      this.databasePath = undefined;
-    }
-    if (step === 'database' || step === 'runtime') {
-      this.runtimePath = undefined;
-      this.schemaName = undefined;
+    const added = (yield flowResult(tab.confirm())) as boolean;
+    if (added) {
+      // every tab drops what it was still waiting for
+      this.close();
     }
-    this.tableName = undefined;
-    this.tableSearch = '';
   }
 }

package/src/stores/CubeSpecTransferState.ts

@@ -53,8 +53,8 @@ export const getCubeSpecFileName = (name: string | undefined): string => {
 
 /**
  * Export and import of the saved spec (PLAN §10.3), the only way to keep a
- * cube until the Cube store (M8). Both are developer tools for now, labelled
- * "(dev)" (Settled before M1.8).
+ * cube until the Cube store (M8). Labelled "(dev)" until 2026-10-10, when the
+ * user dropped the label for the demo (PLAN §7.8).
  */
 export class CubeSpecTransferState {
   readonly editorState: CubeEditorState;