@finos/legend-cube-builder 0.0.3 → 0.0.5

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

@@ -0,0 +1,250 @@
+/**
+ * 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,
+  CubeModelReadKind,
+} 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 =
+    CubeSourcePickerTabKey.PROJECT;
+  override readonly label: string = '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;
+  }
+
+  /** A project's tables; its functions have the Project Function tab */
+  override get readKinds(): readonly CubeModelReadKind[] {
+    return [CubeModelReadKind.TABLE];
+  }
+
+  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,
+        );
+      } else {
+        this.followFixedRuntime();
+      }
+      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);
+  }
+}
+
+/**
+ * The source dialog's Project Function tab (PLAN §6.5): as the Project
+ * Database tab, a published project and one of its released versions, then
+ * one of the project's own functions that return a relation, its runtime and
+ * its values. Its own tab (user, 2026-10-13); a function and the tables of
+ * the same project and version still join in one cube, each from its tab.
+ */
+export class CubeProjectFunctionTabState extends CubeProjectTabState {
+  override readonly key = CubeSourcePickerTabKey.PROJECT_FUNCTION;
+  override readonly label = 'Project Function';
+
+  constructor(editorState: CubeEditorState) {
+    super(editorState);
+    this.readKind = CubeModelReadKind.FUNCTION;
+  }
+
+  override get readKinds(): readonly CubeModelReadKind[] {
+    return [CubeModelReadKind.FUNCTION];
+  }
+}

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

@@ -0,0 +1,288 @@
+/**
+ * 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,
+  type Schema,
+  SERVICE_SOURCE_DEFINITION,
+  ServiceSource,
+} from '@finos/legend-cube';
+import type { GeneratorFn } from '@finos/legend-shared';
+import {
+  action,
+  computed,
+  flow,
+  flowResult,
+  makeObservable,
+  observable,
+} from 'mobx';
+import { CUBE_SERVICE_MESSAGE } from '../../__lib__/LegendCubeServiceLabels.js';
+import { CubeEngineError } from '../../graph-manager/CubeEngine.js';
+import {
+  createCubeServiceModel,
+  isCubeServiceModel,
+} from '../../graph-manager/CubeService.js';
+import type {
+  CubeServiceCatalog,
+  CubeServiceSummary,
+} from '../../graph-manager/CubeServiceCatalog.js';
+import type { CubeEditorState } from '../CubeEditorState.js';
+import { recheckCubeServiceSources } from '../CubeServiceRecheck.js';
+import {
+  type CubeSourcePickerTab,
+  CubeSourcePickerTabKey,
+} from './CubeSourcePickerTab.js';
+
+/** What failed in the tab: its first line, and the rest on demand */
+export interface CubeServiceTabError {
+  readonly message: string;
+  readonly detail?: string | undefined;
+}
+
+/** The most services the list shows: a registry can hold thousands */
+export const CUBE_SERVICE_LIST_LIMIT = 200;
+
+const toError = (error: unknown): CubeServiceTabError => {
+  if (error instanceof CubeEngineError) {
+    return {
+      message: error.firstLine,
+      detail: error.detail !== error.firstLine ? error.detail : undefined,
+    };
+  }
+  return { message: error instanceof Error ? error.message : String(error) };
+};
+
+/**
+ * The source dialog's Service tab (PLAN §6.4), in progress: the deployed
+ * services, searched by title, name and pattern. Add puts the picked one on
+ * the canvas, typed as services are (`recheckCubeServiceSources`), which for
+ * now says it can't be read; the first saves a service model as the cube's.
+ */
+export class CubeServiceTabState implements CubeSourcePickerTab {
+  readonly key = CubeSourcePickerTabKey.SERVICE;
+  readonly label = 'Service';
+  readonly editorState: CubeEditorState;
+
+  services: readonly CubeServiceSummary[] | undefined;
+  search = '';
+  /** The picked service's pattern */
+  pattern: string | undefined;
+  isLoading = false;
+  isAdding = false;
+  error: CubeServiceTabError | undefined;
+
+  /** Each counts its calls: a later call, or closing the dialog, drops an earlier answer */
+  private listRequest = 0;
+  private confirmRequest = 0;
+
+  constructor(editorState: CubeEditorState) {
+    makeObservable(this, {
+      services: observable.ref,
+      search: observable,
+      pattern: observable,
+      isLoading: observable,
+      isAdding: observable,
+      error: observable.ref,
+      isAvailable: computed,
+      isBusy: computed,
+      matchingServices: computed,
+      shownServices: computed,
+      service: computed,
+      canConfirm: computed,
+      setSearch: action,
+      selectService: action,
+      retry: action,
+      open: action,
+      close: action,
+      loadServices: flow,
+      confirm: flow,
+    });
+    this.editorState = editorState;
+  }
+
+  get catalog(): CubeServiceCatalog | undefined {
+    return this.editorState.host.serviceCatalog;
+  }
+
+  /** Hosts without a service catalog have no services */
+  get isAvailable(): boolean {
+    return this.catalog !== undefined;
+  }
+
+  get isBusy(): boolean {
+    return this.isLoading || this.isAdding;
+  }
+
+  ownsContext(context: CubeContext): boolean {
+    return isCubeServiceModel(context.model);
+  }
+
+  /** The services whose title, name or pattern holds the search text */
+  get matchingServices(): readonly CubeServiceSummary[] {
+    const search = this.search.trim().toLowerCase();
+    return (this.services ?? []).filter((service) =>
+      [service.title ?? '', service.name, service.pattern].some((text) =>
+        text.toLowerCase().includes(search),
+      ),
+    );
+  }
+
+  /** The first matching services, up to the list's limit */
+  get shownServices(): readonly CubeServiceSummary[] {
+    return this.matchingServices.slice(0, CUBE_SERVICE_LIST_LIMIT);
+  }
+
+  get service(): CubeServiceSummary | undefined {
+    return this.services?.find((each) => each.pattern === this.pattern);
+  }
+
+  get canConfirm(): boolean {
+    return (
+      this.isAvailable &&
+      !this.editorState.readOnly &&
+      !this.isAdding &&
+      this.service !== undefined
+    );
+  }
+
+  setSearch(search: string): void {
+    this.search = search;
+  }
+
+  selectService(pattern: string): void {
+    if (this.services?.some((each) => each.pattern === pattern)) {
+      this.pattern = pattern;
+    }
+  }
+
+  /** Reads the list again, after it failed */
+  retry(): void {
+    this.error = undefined;
+    flowResult(this.loadServices()).catch(
+      this.editorState.host.applicationStore.alertUnhandledError,
+    );
+  }
+
+  /** When the dialog opens on the tab: reads the list, unless it is read or on its way */
+  open(): void {
+    this.error = undefined;
+    if (this.services === undefined && !this.isLoading) {
+      flowResult(this.loadServices()).catch(
+        this.editorState.host.applicationStore.alertUnhandledError,
+      );
+    }
+  }
+
+  close(): void {
+    this.listRequest++;
+    this.confirmRequest++;
+    this.isLoading = false;
+    this.isAdding = false;
+  }
+
+  *loadServices(): GeneratorFn<void> {
+    const { catalog } = this;
+    if (!catalog) {
+      return;
+    }
+    const request = ++this.listRequest;
+    this.isLoading = true;
+    this.error = undefined;
+    try {
+      const services =
+        (yield catalog.listServices()) as readonly CubeServiceSummary[];
+      if (request === this.listRequest) {
+        this.services = services;
+      }
+    } catch (error) {
+      if (request === this.listRequest) {
+        this.error = toError(error);
+      }
+    } finally {
+      if (request === this.listRequest) {
+        this.isLoading = false;
+      }
+    }
+  }
+
+  /**
+   * Adds the picked service, typed as services are; the first saves a
+   * service model as the cube's, in the same undo step
+   */
+  *confirm(): GeneratorFn<boolean> {
+    if (!this.canConfirm) {
+      return false;
+    }
+    const { editorState } = this;
+    const service = this.service as CubeServiceSummary;
+    const request = ++this.confirmRequest;
+    this.isAdding = true;
+    this.error = undefined;
+    try {
+      const coordinates = { pattern: service.pattern, service: service.name };
+      const model =
+        editorState.document.context?.model ?? createCubeServiceModel();
+      const answers = (yield recheckCubeServiceSources(this.catalog, model, [
+        SERVICE_SOURCE_DEFINITION.fromCoordinates(
+          ServiceSource.TYPE,
+          coordinates,
+        ),
+      ])) as Map<string, Schema | CubeEngineError>;
+      if (request !== this.confirmRequest) {
+        return false;
+      }
+      const [answer] = [...answers.values()];
+      // the cube as it is now: it may have changed meanwhile
+      const { document } = editorState;
+      const node = SERVICE_SOURCE_DEFINITION.resolve(
+        SERVICE_SOURCE_DEFINITION.fromCoordinates(
+          document.query.generateId(ServiceSource.TYPE),
+          coordinates,
+        ),
+        answer === undefined || answer instanceof CubeEngineError
+          ? {
+              kind: 'failed',
+              message: answer?.detail ?? CUBE_SERVICE_MESSAGE.NOT_READABLE,
+            }
+          : { kind: 'resolved', schema: answer },
+      );
+      if (
+        (document.context !== undefined &&
+          !isCubeServiceModel(document.context.model)) ||
+        !document.query.canAdd(node)
+      ) {
+        throw new Error(CUBE_SERVICE_MESSAGE.CUBE_CHANGED);
+      }
+      const query = document.query.add(node);
+      editorState.applyDocument(
+        document.context
+          ? document.withQuery(query)
+          : document.withContext({ model }).withQuery(query),
+      );
+      this.pattern = undefined;
+      return true;
+    } catch (error) {
+      if (request === this.confirmRequest) {
+        this.error = toError(error);
+      }
+      return false;
+    } finally {
+      if (request === this.confirmRequest) {
+        this.isAdding = false;
+      }
+    }
+  }
+}

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

@@ -0,0 +1,79 @@
+/**
+ * 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, Query } from '@finos/legend-cube';
+import type { GeneratorFn } from '@finos/legend-shared';
+
+export enum CubeSourcePickerTabKey {
+  MODEL = 'model',
+  DIRECT_CONNECTION = 'directConnection',
+  DATA_PRODUCT = 'dataProduct',
+  INGEST = 'ingest',
+  PROJECT = 'project',
+  PROJECT_FUNCTION = 'projectFunction',
+  SERVICE = 'service',
+}
+
+/**
+ * A tab of the source dialog (PLAN §6.1, §6.8): one way to find a source,
+ * e.g. a model's tables or a database connection's. The dialog opens one tab
+ * at a time and runs its Add; a cube's fixed context belongs to one tab,
+ * which then is the only one enabled.
+ */
+export interface CubeSourcePickerTab {
+  readonly key: CubeSourcePickerTabKey;
+  readonly label: string;
+  /** The host serves it; a tab it doesn't serve isn't shown */
+  readonly isAvailable: boolean;
+  /** Something is loading or being typed */
+  readonly isBusy: boolean;
+  readonly canConfirm: boolean;
+  /** Whether a cube's fixed context is this tab's, e.g. its saved connection */
+  ownsContext(context: CubeContext): boolean;
+  /** When the dialog opens on the tab, or the user switches to it */
+  open(): void;
+  /** When the dialog closes: answers still on their way are dropped */
+  close(): void;
+  /** How many sources Add adds, when the tab picks several at once; one when left out */
+  readonly pickedCount?: number;
+  /** Adds the picked sources; gives whether every one was added */
+  confirm(): GeneratorFn<boolean>;
+}
+
+/**
+ * Ids for several new nodes of a type, none taken by the query nor by each
+ * other: `generateId` sees only the query's nodes, so asking it again gives
+ * the same id
+ */
+export const generateCubeNodeIds = (
+  query: Query,
+  type: string,
+  count: number,
+): string[] => {
+  const first = query.generateId(type);
+  const ids = [first];
+  const number = Number(first.slice(type.length));
+  for (let next = number + 1; ids.length < count; next += 1) {
+    const id = `${type}${next}`;
+    if (!query.getNode(id)) {
+      ids.push(id);
+    }
+  }
+  return ids;
+};
+
+/** How long the clicks on a list's tables pause before the table picked last is previewed */
+export const CUBE_TABLE_PREVIEW_DELAY_MS = 250;