@finos/legend-cube-builder 0.0.4 → 0.0.6

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

@@ -32,7 +32,10 @@ import {
 } 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 {
+  CubeInlineModelTabState,
+  CubeModelReadKind,
+} from './CubeInlineModelTabState.js';
 import { CubeSourcePickerTabKey } from './CubeSourcePickerTab.js';
 
 /** A project as the tab keys it: `group:artifact` */
@@ -52,8 +55,9 @@ const toMessage = (error: unknown): string => {
  * 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';
+  override readonly key: CubeSourcePickerTabKey =
+    CubeSourcePickerTabKey.PROJECT;
+  override readonly label: string = 'Project Database';
 
   projects: readonly CubeProjectSummary[] | undefined;
   isLoadingProjects = false;
@@ -87,6 +91,11 @@ export class CubeProjectTabState extends CubeInlineModelTabState {
     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;
   }
@@ -122,6 +131,8 @@ export class CubeProjectTabState extends CubeInlineModelTabState {
         flowResult(this.selectModel(fixedModel)).catch(
           this.editorState.host.applicationStore.alertUnhandledError,
         );
+      } else {
+        this.followFixedRuntime();
       }
       return;
     }
@@ -216,3 +227,24 @@ export class CubeProjectTabState extends CubeInlineModelTabState {
     ).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

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import type { CubeContext } from '@finos/legend-cube';
+import type { CubeContext, Query } from '@finos/legend-cube';
 import type { GeneratorFn } from '@finos/legend-shared';
 
 export enum CubeSourcePickerTabKey {
@@ -23,6 +23,8 @@ export enum CubeSourcePickerTabKey {
   DATA_PRODUCT = 'dataProduct',
   INGEST = 'ingest',
   PROJECT = 'project',
+  PROJECT_FUNCTION = 'projectFunction',
+  SERVICE = 'service',
 }
 
 /**
@@ -45,6 +47,33 @@ export interface CubeSourcePickerTab {
   open(): void;
   /** When the dialog closes: answers still on their way are dropped */
   close(): void;
-  /** Adds the picked source; gives whether it was added */
+  /** 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;

package/src/stores/variant/CubeJson.ts

@@ -0,0 +1,229 @@
+/**
+ * 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.
+ */
+
+// A Variant cell's JSON document (PLAN §11.20), as the engine sends it: its
+// compact text. Read here with each number kept as written, so `1` and `1.0`
+// stay apart and an id past 2^53 keeps its digits, and each object's keys in
+// the order written (a JS object would put keys that look like integers first).
+
+/** A JSON value, numbers kept as written and keys in their order */
+export type CubeJsonNode =
+  | {
+      readonly kind: 'object';
+      readonly entries: readonly (readonly [string, CubeJsonNode])[];
+    }
+  | { readonly kind: 'array'; readonly items: readonly CubeJsonNode[] }
+  | { readonly kind: 'number'; readonly text: string }
+  | { readonly kind: 'string'; readonly value: string }
+  | { readonly kind: 'boolean'; readonly value: boolean }
+  | { readonly kind: 'null' };
+
+const WHITESPACE = new Set([' ', '\t', '\n', '\r']);
+const NUMBER = /-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/uy;
+
+/** A JSON document; throws a `SyntaxError` on text that isn't one */
+export const parseCubeJson = (text: string): CubeJsonNode => {
+  let at = 0;
+  const fail = (what: string): never => {
+    throw new SyntaxError(`${what} at ${at} in JSON`);
+  };
+  const skipWhitespace = (): void => {
+    while (at < text.length && WHITESPACE.has(text.charAt(at))) {
+      at += 1;
+    }
+  };
+  const readString = (): string => {
+    const start = at;
+    at += 1;
+    while (at < text.length && text.charAt(at) !== '"') {
+      at += text.charAt(at) === '\\' ? 2 : 1;
+    }
+    if (at >= text.length) {
+      fail('An unterminated string');
+    }
+    at += 1;
+    // a string loses nothing through JSON.parse: only numbers do
+    return JSON.parse(text.slice(start, at)) as string;
+  };
+  const readValue = (): CubeJsonNode => {
+    skipWhitespace();
+    const char = text.charAt(at);
+    if (char === '{') {
+      at += 1;
+      const entries: (readonly [string, CubeJsonNode])[] = [];
+      skipWhitespace();
+      if (text.charAt(at) === '}') {
+        at += 1;
+        return { kind: 'object', entries };
+      }
+      for (;;) {
+        skipWhitespace();
+        if (text.charAt(at) !== '"') {
+          fail('A key expected');
+        }
+        const key = readString();
+        skipWhitespace();
+        if (text.charAt(at) !== ':') {
+          fail('":" expected');
+        }
+        at += 1;
+        entries.push([key, readValue()]);
+        skipWhitespace();
+        if (text.charAt(at) === ',') {
+          at += 1;
+        } else if (text.charAt(at) === '}') {
+          at += 1;
+          return { kind: 'object', entries };
+        } else {
+          fail('"," or "}" expected');
+        }
+      }
+    }
+    if (char === '[') {
+      at += 1;
+      const items: CubeJsonNode[] = [];
+      skipWhitespace();
+      if (text.charAt(at) === ']') {
+        at += 1;
+        return { kind: 'array', items };
+      }
+      for (;;) {
+        items.push(readValue());
+        skipWhitespace();
+        if (text.charAt(at) === ',') {
+          at += 1;
+        } else if (text.charAt(at) === ']') {
+          at += 1;
+          return { kind: 'array', items };
+        } else {
+          fail('"," or "]" expected');
+        }
+      }
+    }
+    if (char === '"') {
+      return { kind: 'string', value: readString() };
+    }
+    for (const [word, node] of [
+      ['true', { kind: 'boolean', value: true }],
+      ['false', { kind: 'boolean', value: false }],
+      ['null', { kind: 'null' }],
+    ] as const) {
+      if (text.startsWith(word, at)) {
+        at += word.length;
+        return node;
+      }
+    }
+    NUMBER.lastIndex = at;
+    const number = NUMBER.exec(text);
+    if (!number) {
+      return fail('A value expected');
+    }
+    at += number[0].length;
+    return { kind: 'number', text: number[0] };
+  };
+  const value = readValue();
+  skipWhitespace();
+  if (at < text.length) {
+    fail('Text after the value');
+  }
+  return value;
+};
+
+/** The document, or `undefined` for text that isn't JSON */
+export const readCubeJson = (text: string): CubeJsonNode | undefined => {
+  try {
+    return parseCubeJson(text);
+  } catch {
+    return undefined;
+  }
+};
+
+/**
+ * A key or a string shown bare when it can't be mistaken for anything else:
+ * not empty, none of the notation's punctuation or a line break, no space at
+ * either end, and not a number, `true`, `false` or `null`; JSON-quoted
+ * otherwise
+ */
+const showText = (text: string): string =>
+  text !== '' &&
+  !/[,:{}[\]"\n\r\t]/u.test(text) &&
+  text === text.trim() &&
+  !/^(?:true|false|null|-?\d.*)$/u.test(text)
+    ? text
+    : JSON.stringify(text);
+
+const showNode = (node: CubeJsonNode): string => {
+  switch (node.kind) {
+    case 'object':
+      return `{${node.entries.map(([key, value]) => `${showText(key)}: ${showNode(value)}`).join(', ')}}`;
+    case 'array':
+      return `[${node.items.map(showNode).join(', ')}]`;
+    case 'string':
+      return showText(node.value);
+    case 'number':
+      return node.text;
+    case 'boolean':
+      return String(node.value);
+    case 'null':
+      return 'null';
+    default:
+      return '';
+  }
+};
+
+/**
+ * A Variant cell on one line, for the eye (PLAN §11.20, as legend-lite's
+ * Data Cube shows one): `{name: ann, tier: gold}`, `[a, b]`, numbers as
+ * written. Text that isn't JSON is shown as it is; the value itself stays the
+ * JSON text, for copying and export.
+ */
+export const formatCubeJsonLine = (text: string): string => {
+  const node = readCubeJson(text);
+  return node ? showNode(node) : text;
+};
+
+/** The document as JSON, indented two spaces, numbers as written */
+export const formatCubeJsonPretty = (node: CubeJsonNode, depth = 0): string => {
+  const indent = '  '.repeat(depth + 1);
+  const closing = '  '.repeat(depth);
+  switch (node.kind) {
+    case 'object':
+      return node.entries.length === 0
+        ? '{}'
+        : `{\n${node.entries
+            .map(
+              ([key, value]) =>
+                `${indent}${JSON.stringify(key)}: ${formatCubeJsonPretty(value, depth + 1)}`,
+            )
+            .join(',\n')}\n${closing}}`;
+    case 'array':
+      return node.items.length === 0
+        ? '[]'
+        : `[\n${node.items
+            .map((item) => `${indent}${formatCubeJsonPretty(item, depth + 1)}`)
+            .join(',\n')}\n${closing}]`;
+    case 'string':
+      return JSON.stringify(node.value);
+    case 'number':
+      return node.text;
+    case 'boolean':
+      return String(node.value);
+    case 'null':
+      return 'null';
+    default:
+      return '';
+  }
+};