@finos/legend-cube-builder 0.0.4 → 0.0.6

package/src/components/spec-transfer/CubeImportPureDialog.tsx

@@ -0,0 +1,122 @@
+/**
+ * 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 {
+  Dialog,
+  Modal,
+  ModalBody,
+  ModalFooter,
+  ModalFooterButton,
+  ModalHeader,
+  PanelLoadingIndicator,
+} from '@finos/legend-art';
+import { flowResult } from 'mobx';
+import { observer } from 'mobx-react-lite';
+import { LEGEND_CUBE_TEST_ID } from '../../__lib__/LegendCubeTesting.js';
+import type { CubeEditorState } from '../../stores/CubeEditorState.js';
+import { CUBE_PRIMARY_BUTTON_DARK_MODE } from '../CubeDialogTheme.js';
+
+const TEXT_AREA_CLASS_NAME =
+  'h-80 w-full resize-none rounded-sm border border-[var(--color-border-default)] bg-[var(--color-bg-input)] p-1 font-mono text-sm text-[var(--color-text-primary)]';
+
+/**
+ * Import Pure (PLAN §11.18): a lambda pasted as Pure, as Show Pure shows one,
+ * or as the engine's JSON, read into the steps Cube writes it with, in
+ * place of this cube
+ */
+export const CubeImportPureDialog = observer(
+  (props: { editorState: CubeEditorState }) => {
+    const { editorState } = props;
+    const { lambdaImport } = editorState;
+    const { applicationStore } = editorState.host;
+    const darkMode =
+      !applicationStore.layoutService.TEMPORARY__isLightColorThemeEnabled;
+    const importText = (): void => {
+      flowResult(lambdaImport.importText()).catch(
+        applicationStore.alertUnhandledError,
+      );
+    };
+    return (
+      <Dialog
+        open={lambdaImport.isDialogOpen}
+        onClose={() => lambdaImport.closeDialog()}
+      >
+        <Modal darkMode={darkMode} className="w-[720px] max-w-full">
+          <ModalHeader>
+            <div className="modal__title">Import Pure</div>
+          </ModalHeader>
+          <PanelLoadingIndicator isLoading={lambdaImport.isImporting} />
+          <ModalBody>
+            <div
+              className="flex flex-col gap-2"
+              data-testid={LEGEND_CUBE_TEST_ID.IMPORT_PURE}
+            >
+              <div className="text-base text-[var(--color-text-secondary)]">
+                Paste a query, as Show Pure shows one, e.g.{' '}
+                <code>
+                  {'|#>{db::Store.SCHEMA.TABLE}#->filter(x | $x.ID > 1)'}
+                </code>
+                , or its JSON. Cube reads it into steps that replace this cube;
+                Undo brings it back. Its sources are read where the source
+                dialog reads them.
+              </div>
+              <textarea
+                className={TEXT_AREA_CLASS_NAME}
+                aria-label="Pure query"
+                placeholder="Pure query"
+                spellCheck={false}
+                value={lambdaImport.text}
+                onChange={(event) => lambdaImport.setText(event.target.value)}
+              />
+              {lambdaImport.dialogError !== undefined && (
+                <div
+                  className="break-words text-base text-[var(--color-status-error)]"
+                  role="alert"
+                >
+                  {lambdaImport.dialogError.message}
+                  {lambdaImport.dialogError.detail !== undefined && (
+                    <details>
+                      <summary className="cursor-pointer">Details</summary>
+                      <pre className="whitespace-pre-wrap text-sm">
+                        {lambdaImport.dialogError.detail}
+                      </pre>
+                    </details>
+                  )}
+                </div>
+              )}
+            </div>
+          </ModalBody>
+          <ModalFooter>
+            <ModalFooterButton
+              darkMode={CUBE_PRIMARY_BUTTON_DARK_MODE}
+              formatText={false}
+              text="Import"
+              disabled={!lambdaImport.text.trim() || lambdaImport.isImporting}
+              onClick={importText}
+            />
+            <ModalFooterButton
+              darkMode={darkMode}
+              formatText={false}
+              type="secondary"
+              text="Cancel"
+              onClick={() => lambdaImport.closeDialog()}
+            />
+          </ModalFooter>
+        </Modal>
+      </Dialog>
+    );
+  },
+);

package/src/components/spec-transfer/CubeSpecTransferDialog.tsx

@@ -23,10 +23,15 @@ import {
   ModalHeader,
   PanelLoadingIndicator,
 } from '@finos/legend-art';
+import { CodeEditor } from '@finos/legend-lego/code-editor';
 import { flowResult } from 'mobx';
 import { observer } from 'mobx-react-lite';
 import type { CubeEditorState } from '../../stores/CubeEditorState.js';
 import { CUBE_SPEC_TRANSFER_MODE } from '../../stores/CubeSpecTransferState.js';
+import { CUBE_PRIMARY_BUTTON_DARK_MODE } from '../CubeDialogTheme.js';
+
+/** The code editor's language: legend-code-editor's `CODE_EDITOR_LANGUAGE.JSON` */
+const JSON_LANGUAGE = 'json';
 
 const TEXT_AREA_CLASS_NAME =
   'h-80 w-full resize-none rounded-sm border border-[var(--color-border-default)] bg-[var(--color-bg-input)] p-1 font-mono text-sm text-[var(--color-text-primary)]';
@@ -60,12 +65,20 @@ export const CubeSpecTransferDialog = observer(
             <div className="flex flex-col gap-2">
               {isExport ? (
                 transfer.exportText !== undefined && (
-                  <textarea
-                    className={TEXT_AREA_CLASS_NAME}
+                  // a code editor, so each object and list folds from the gutter
+                  <div
+                    className="h-80 w-full overflow-hidden rounded-sm border border-[var(--color-border-default)]"
                     aria-label="Cube spec"
-                    readOnly={true}
-                    value={transfer.exportText}
-                  />
+                  >
+                    <CodeEditor
+                      inputValue={transfer.exportText}
+                      language={JSON_LANGUAGE}
+                      isReadOnly={true}
+                      hideMinimap={true}
+                      hideActionBar={true}
+                      extraEditorOptions={{ scrollBeyondLastLine: false }}
+                    />
+                  </div>
                 )
               ) : (
                 <>
@@ -115,7 +128,7 @@ export const CubeSpecTransferDialog = observer(
             {isExport ? (
               <>
                 <ModalFooterButton
-                  darkMode={darkMode}
+                  darkMode={CUBE_PRIMARY_BUTTON_DARK_MODE}
                   formatText={false}
                   text="Copy"
                   disabled={transfer.exportText === undefined}
@@ -126,7 +139,7 @@ export const CubeSpecTransferDialog = observer(
                   }}
                 />
                 <ModalFooterButton
-                  darkMode={darkMode}
+                  darkMode={CUBE_PRIMARY_BUTTON_DARK_MODE}
                   formatText={false}
                   text="Download"
                   disabled={transfer.exportText === undefined}
@@ -135,7 +148,7 @@ export const CubeSpecTransferDialog = observer(
               </>
             ) : (
               <ModalFooterButton
-                darkMode={darkMode}
+                darkMode={CUBE_PRIMARY_BUTTON_DARK_MODE}
                 formatText={false}
                 text="Import"
                 disabled={!transfer.importText.trim() || transfer.isReadingFile}

package/src/components/tour/CubeTour.tsx

@@ -0,0 +1,317 @@
+/**
+ * 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 { BasePopper } from '@finos/legend-art';
+import { noop } from '@finos/legend-shared';
+import { observer } from 'mobx-react-lite';
+import { useEffect, useId, useMemo, useRef, useState } from 'react';
+import { createPortal } from 'react-dom';
+import {
+  CUBE_TOUR_ANCHOR_ATTRIBUTE,
+  CUBE_TOUR_LABEL,
+  type CUBE_TOUR_ANCHOR,
+  type CubeTourStep,
+} from '../../__lib__/LegendCubeTour.js';
+import type { CubeEditorState } from '../../stores/CubeEditorState.js';
+import { CubeButton } from '../CubeButton.js';
+
+/**
+ * Above the canvas, the grid and the node editor (1250), below MUI's dialogs
+ * (1300); inside the dialog that hosts the page, if one does
+ */
+export const CUBE_TOUR_Z_INDEX = 1290;
+
+/** Room around the controls shown, and between them and the card */
+const PADDING = 4;
+const GAP = 12;
+/** The card's width (Legend's root is 62.5%, so it is written in pixels) */
+const CARD_WIDTH = 340;
+const DIM = 'rgba(0, 0, 0, 0.45)';
+
+const MODIFIERS = [
+  { name: 'offset', options: { offset: [0, GAP + PADDING] } },
+  { name: 'flip', options: { padding: GAP } },
+  {
+    name: 'preventOverflow',
+    options: { rootBoundary: 'viewport', padding: GAP, altAxis: true },
+  },
+];
+
+type CubePopperInstance = NonNullable<
+  Extract<
+    React.ComponentProps<typeof BasePopper>['popperRef'],
+    React.RefObject<unknown>
+  >['current']
+>;
+
+interface Box {
+  left: number;
+  top: number;
+  width: number;
+  height: number;
+}
+
+/** The page's controls that carry the anchor */
+const findAnchored = (root: Element, anchor: CUBE_TOUR_ANCHOR): Element[] =>
+  Array.from(
+    root.querySelectorAll(`[${CUBE_TOUR_ANCHOR_ATTRIBUTE}~="${anchor}"]`),
+  );
+
+/** The box around the anchor's controls that have a size; none if none has */
+const boxOf = (root: Element, anchor: CUBE_TOUR_ANCHOR): Box | undefined =>
+  findAnchored(root, anchor)
+    .map((element) => element.getBoundingClientRect())
+    .filter((rect) => rect.width > 0 || rect.height > 0)
+    .reduce<Box | undefined>((box, rect) => {
+      if (!box) {
+        return {
+          left: rect.left,
+          top: rect.top,
+          width: rect.width,
+          height: rect.height,
+        };
+      }
+      const left = Math.min(box.left, rect.left);
+      const top = Math.min(box.top, rect.top);
+      return {
+        left,
+        top,
+        width: Math.max(box.left + box.width, rect.right) - left,
+        height: Math.max(box.top + box.height, rect.bottom) - top,
+      };
+    }, undefined);
+
+const isSameBox = (a: Box | undefined, b: Box | undefined): boolean =>
+  a === b ||
+  (a !== undefined &&
+    b !== undefined &&
+    a.left === b.left &&
+    a.top === b.top &&
+    a.width === b.width &&
+    a.height === b.height);
+
+/**
+ * The editor's guided tour (PLAN §11.21): the page dimmed but for the
+ * current step's controls, and a card beside them, or in the middle of the
+ * page for a step that points at nothing. The controls are followed as the
+ * page moves them (a panel resized, the grid loaded). Clicks on the page
+ * are held while it shows; Esc ends it, the arrow keys move through it.
+ */
+export const CubeTour = observer(
+  (props: {
+    editorState: CubeEditorState;
+    /** The page, whose controls the steps point at */
+    root: HTMLElement | null;
+  }) => {
+    const { editorState, root } = props;
+    const { tour } = editorState;
+    const { step } = tour;
+    const titleId = useId();
+    const textId = useId();
+    const [box, setBox] = useState<Box | undefined>(undefined);
+    const popperRef = useRef<CubePopperInstance>(null);
+    const isShown = useMemo(
+      () =>
+        (candidate: CubeTourStep): boolean =>
+          candidate.anchor === undefined ||
+          (root !== null && findAnchored(root, candidate.anchor).length > 0),
+      [root],
+    );
+
+    // the step's controls followed, frame by frame, while it shows
+    const anchor = step?.anchor;
+    useEffect(() => {
+      if (anchor === undefined || !root) {
+        setBox(undefined);
+        return undefined;
+      }
+      let frame = 0;
+      const follow = (): void => {
+        const next = boxOf(root, anchor);
+        setBox((current) => (isSameBox(current, next) ? current : next));
+        frame = requestAnimationFrame(follow);
+      };
+      follow();
+      return () => cancelAnimationFrame(frame);
+    }, [anchor, root]);
+    useEffect(() => {
+      popperRef.current?.update().catch(noop());
+    }, [box]);
+
+    // the tour's keys come first: the page's shortcuts wait while it shows
+    const isOpen = step !== undefined;
+    useEffect(() => {
+      if (!isOpen) {
+        return undefined;
+      }
+      const onKeyDown = (event: KeyboardEvent): void => {
+        if (event.key === 'Escape') {
+          tour.close();
+        } else if (event.key === 'ArrowRight') {
+          tour.move(1, isShown);
+        } else if (event.key === 'ArrowLeft') {
+          tour.move(-1, isShown);
+        } else {
+          return;
+        }
+        event.preventDefault();
+        event.stopPropagation();
+      };
+      window.addEventListener('keydown', onKeyDown, true);
+      return () => window.removeEventListener('keydown', onKeyDown, true);
+    }, [isOpen, tour, isShown]);
+
+    const spotlight = useMemo(
+      () =>
+        box && {
+          left: box.left - PADDING,
+          top: box.top - PADDING,
+          width: box.width + 2 * PADDING,
+          height: box.height + 2 * PADDING,
+        },
+      [box],
+    );
+    // the popper reads the spotlight wherever it places the card
+    const latest = useRef(spotlight);
+    latest.current = spotlight;
+    const virtualAnchor = useMemo(
+      () => ({
+        getBoundingClientRect: (): DOMRect => {
+          const current = latest.current ?? {
+            left: 0,
+            top: 0,
+            width: 0,
+            height: 0,
+          };
+          return DOMRect.fromRect({
+            x: current.left,
+            y: current.top,
+            width: current.width,
+            height: current.height,
+          });
+        },
+      }),
+      [],
+    );
+
+    if (!step || !root) {
+      return null;
+    }
+    // counted over the whole tour, steady while an example loads and adds
+    // the controls of later steps; a step skipped skips its number
+    const position = tour.index + 1;
+    const isLast = tour.steps.filter(isShown).at(-1) === step;
+    // a page hosted in a dialog, as Studio hosts Cube, keeps the tour in the
+    // dialog's layer, above the page
+    const container =
+      root.closest<HTMLElement>('.MuiDialog-root') ?? root.ownerDocument.body;
+    const card = (
+      <div
+        // a new card for each step, so its Next button takes the focus
+        key={tour.index}
+        className="legend-cube__tour flex flex-col gap-2 rounded-md border border-[var(--color-border-default)] bg-[var(--color-bg-elevated)] p-3 text-[var(--color-text-primary)] shadow-lg"
+        style={{ width: CARD_WIDTH, maxWidth: `calc(100vw - ${2 * GAP}px)` }}
+        role="dialog"
+        aria-modal="true"
+        aria-labelledby={titleId}
+        aria-describedby={textId}
+      >
+        <div className="flex items-baseline gap-2">
+          <h2 id={titleId} className="min-w-0 flex-1 text-lg font-medium">
+            {step.title}
+          </h2>
+          <span className="shrink-0 text-sm text-[var(--color-text-secondary)]">
+            {CUBE_TOUR_LABEL.progress(position, tour.steps.length)}
+          </span>
+        </div>
+        <p id={textId} className="text-base leading-snug">
+          {step.text}
+          {tour.openedExample && tour.index === 0 && (
+            <> {CUBE_TOUR_LABEL.EXAMPLE_OPENED}</>
+          )}
+        </p>
+        <div className="flex items-center gap-2">
+          {!isLast && (
+            <button
+              type="button"
+              className="text-sm text-[var(--color-text-secondary)] underline hover:text-[var(--color-text-primary)]"
+              onClick={() => tour.close()}
+            >
+              {CUBE_TOUR_LABEL.END}
+            </button>
+          )}
+          <span className="flex-1" />
+          {position > 1 && (
+            <CubeButton onClick={() => tour.move(-1, isShown)}>
+              {CUBE_TOUR_LABEL.BACK}
+            </CubeButton>
+          )}
+          <CubeButton
+            primary={true}
+            // the keyboard follows the tour: Enter moves on
+            autoFocus={true}
+            onClick={() => tour.move(1, isShown)}
+          >
+            {isLast ? CUBE_TOUR_LABEL.DONE : CUBE_TOUR_LABEL.NEXT}
+          </CubeButton>
+        </div>
+      </div>
+    );
+    return createPortal(
+      <div
+        className="legend-cube__tour-layer"
+        style={{ position: 'fixed', inset: 0, zIndex: CUBE_TOUR_Z_INDEX }}
+        // the page underneath takes no clicks, and shows no menu, meanwhile
+        onContextMenu={(event) => event.preventDefault()}
+      >
+        {spotlight ? (
+          <>
+            <div
+              aria-hidden={true}
+              style={{
+                position: 'fixed',
+                ...spotlight,
+                borderRadius: 6,
+                boxShadow: `0 0 0 2px var(--color-accent), 0 0 0 9999px ${DIM}`,
+                pointerEvents: 'none',
+              }}
+            />
+            <BasePopper
+              open={true}
+              role="presentation"
+              popperRef={popperRef}
+              anchorEl={virtualAnchor}
+              container={container}
+              placement={step.placement ?? 'bottom'}
+              modifiers={MODIFIERS}
+              style={{ zIndex: CUBE_TOUR_Z_INDEX + 1 }}
+            >
+              {card}
+            </BasePopper>
+          </>
+        ) : (
+          <div
+            className="flex items-center justify-center"
+            style={{ position: 'fixed', inset: 0, background: DIM }}
+          >
+            {card}
+          </div>
+        )}
+      </div>,
+      container,
+    );
+  },
+);

package/src/graph-manager/CubeDataProductCatalog.ts

@@ -15,6 +15,7 @@
  */
 
 import type { Schema } from '@finos/legend-cube';
+import type { PlainObject } from '@finos/legend-shared';
 import {
   type CubeDataProductEnvironmentType,
   type CubeDataProductProject,
@@ -243,3 +244,13 @@ export interface CubeDataProductCatalog {
     signal?: AbortSignal,
   ): Promise<ReadonlyMap<string, CubeAccessPointGroupAccess>>;
 }
+
+/**
+ * Where a data product cube's engine reads the project its data products
+ * are in, as protocol JSON: by default the project at the version they were
+ * deployed from (a pointer); a host's own, e.g. Studio's workspace, whose
+ * data products aren't deployed. Fails with a `CubeEngineError`
+ */
+export interface CubeDataProductModelSource {
+  getProjectModel(project: CubeDataProductProject): Promise<PlainObject>;
+}

package/src/graph-manager/CubeEngine.ts

@@ -84,10 +84,45 @@ export interface CubeOutlineRuntime {
   readonly connections?: readonly CubeOutlineConnection[];
 }
 
-/** What a model offers the source picker: its databases and runtimes, as plain data */
+/** A parameter of a function, as its signature declares it */
+export interface CubeOutlineFunctionParameter {
+  readonly name: string;
+  /** Its type's path, as written, e.g. `Float` */
+  readonly type: string;
+  /** Its multiplicity, as written, e.g. `[1]`, `[0..1]` or `[*]` */
+  readonly multiplicity: string;
+}
+
+/** A column a function declares it returns, e.g. `ID:Integer` */
+export interface CubeOutlineFunctionColumn {
+  readonly name: string;
+  readonly type: string;
+}
+
+/** A function of a model that returns a relation (PLAN §6.5), as plain data */
+export interface CubeOutlineFunction {
+  /** The path the lambda calls it by, e.g. `sales::ordersAbove` */
+  readonly path: string;
+  /** The engine's full name, e.g. `sales::ordersAbove_Float_1__Relation_1_` */
+  readonly signature: string;
+  readonly parameters: readonly CubeOutlineFunctionParameter[];
+  readonly columns: readonly CubeOutlineFunctionColumn[];
+  /**
+   * The runtime it reads through, as its body's `from()` names it, directly
+   * or through a function it calls; none when it leaves the runtime to its
+   * caller
+   */
+  readonly runtime?: string | undefined;
+  /** Why it can't be added, e.g. a parameter Cube can't take a value for */
+  readonly problem?: string | undefined;
+}
+
+/** What a model offers the source picker: its databases, runtimes and functions, as plain data */
 export interface CubeModelOutline {
   readonly databases: readonly CubeOutlineDatabase[];
   readonly runtimes: readonly CubeOutlineRuntime[];
+  /** Its functions that return a relation; optional, as an outline from before them has none */
+  readonly functions?: readonly CubeOutlineFunction[] | undefined;
 }
 
 export enum CubeEngineErrorKind {
@@ -192,8 +227,23 @@ export interface CubeEngine {
     lambda: IR,
     options?: { abortController?: AbortController | undefined },
   ): Promise<CubeResult>;
+  /**
+   * Runs an execution lambda and gives its rows as CSV text (PLAN §11.10):
+   * the engine's own, a header row first, every value as the engine writes
+   * it; rejects with a `CubeEngineError`
+   */
+  exportCsv(
+    model: ModelContext,
+    lambda: IR,
+    options?: { abortController?: AbortController | undefined },
+  ): Promise<string>;
   /** The Pure text of a lambda, for display only: never parsed back */
   renderPure(lambda: IR): Promise<string>;
+  /**
+   * A lambda as the engine receives it, pretty-printed, its numbers kept
+   * exact (PLAN §11.16): for a viewer to copy while debugging a run
+   */
+  serializeLambda(lambda: IR): string;
   /**
    * An Extend column's expression as the engine's JSON (PLAN §11.7), located
    * under the source id; rejects with a `CubeEngineError` placed in the text

package/src/graph-manager/CubeEngineClientSettings.ts

@@ -0,0 +1,64 @@
+/**
+ * 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.
+ */
+
+/** What Dev Settings changes on an engine client: the engine server client's own setters */
+export interface CubeEngineClientControls {
+  setBaseUrl(url: string | undefined): void;
+  setCompression(enabled: boolean): void;
+}
+
+/**
+ * The settings every engine client of Cube shares (PLAN §11.16): the
+ * engine's URL and whether requests are compressed. The engine, the
+ * connection explorer and the catalogs each have their own client, built
+ * from the same configuration; each registers here, so Dev Settings changes
+ * them all at once. A change takes effect from the next request.
+ */
+export class CubeEngineClientSettings {
+  /** The URL the host configured, to go back to */
+  readonly defaultBaseUrl: string | undefined;
+  baseUrl: string | undefined;
+  requestCompression: boolean;
+  private readonly clients: CubeEngineClientControls[] = [];
+
+  constructor(config: {
+    readonly baseUrl?: string | undefined;
+    readonly enableCompression?: boolean | undefined;
+  }) {
+    this.defaultBaseUrl = config.baseUrl;
+    this.baseUrl = config.baseUrl;
+    this.requestCompression = Boolean(config.enableCompression);
+  }
+
+  /** Adds a client built from the same configuration, given the settings changed since */
+  register(client: CubeEngineClientControls): void {
+    this.clients.push(client);
+    if (this.baseUrl !== this.defaultBaseUrl) {
+      client.setBaseUrl(this.baseUrl);
+    }
+    client.setCompression(this.requestCompression);
+  }
+
+  setBaseUrl(url: string | undefined): void {
+    this.baseUrl = url;
+    this.clients.forEach((client) => client.setBaseUrl(url));
+  }
+
+  setRequestCompression(enabled: boolean): void {
+    this.requestCompression = enabled;
+    this.clients.forEach((client) => client.setCompression(enabled));
+  }
+}

package/src/graph-manager/CubeIngest.ts

@@ -118,6 +118,21 @@ export interface CubeIngestUrn {
   readonly definition: string;
 }
 
+/** The URN's environment segment of each class */
+const URN_ENVIRONMENTS: Readonly<
+  Record<CubeDataProductEnvironmentType, string>
+> = {
+  [CubeDataProductEnvironmentType.PRODUCTION]: 'prod',
+  [CubeDataProductEnvironmentType.PRODUCTION_PARALLEL]: 'prod-parallel',
+};
+
+/**
+ * The URN of a definition deployed from SDLC, as `parseCubeIngestUrn` reads
+ * it: for a host naming definitions of its own, e.g. Studio's workspace
+ */
+export const formatCubeIngestUrn = (urn: CubeIngestUrn): string =>
+  `urn:lakehouse:${URN_ENVIRONMENTS[urn.environmentType]}:ingest:definition:alloy-git:${urn.groupId}~${urn.artifactId}~${urn.definition}`;
+
 const SDLC_DEPLOYED_URN =
   /^urn:lakehouse:(?<environment>[^:]+):ingest:definition:alloy-git:(?<groupId>[^~]+)~(?<artifactId>[^~]+)~(?<definition>.+)$/u;