@finos/legend-cube-builder 0.0.3 → 0.0.5

package/src/graph-manager/protocol/pure/CubeEngineBuilder.ts

@@ -14,8 +14,50 @@
  * limitations under the License.
  */
 
-import type { TracerService } from '@finos/legend-shared';
+import type { DepotServerClient } from '@finos/legend-server-depot';
+import { V1_EngineServerClient } from '@finos/legend-graph';
+import type {
+  LakehouseContractServerClient,
+  LakehouseIngestServerClient,
+  LakehousePlatformServerClient,
+} from '@finos/legend-server-lakehouse';
+import type { MarketplaceServerClient } from '@finos/legend-server-marketplace';
+import type { CubeExpressionCodec, IR, JsonObject } from '@finos/legend-cube';
+import {
+  parseLosslessJSON,
+  type PlainObject,
+  stringifyLosslessJSON,
+  type TracerService,
+} from '@finos/legend-shared';
+import type { CubeConnectionExplorer } from '../../CubeConnectionExplorer.js';
+import type {
+  CubeDataProductCatalog,
+  CubeDataProductModelSource,
+  CubeMarketplaceLinkTarget,
+} from '../../CubeDataProductCatalog.js';
 import type { CubeEngine } from '../../CubeEngine.js';
+import type { CubeEngineClientSettings } from '../../CubeEngineClientSettings.js';
+import type {
+  CubeIngestCatalog,
+  CubeIngestDataSet,
+  CubeIngestDefinitionSource,
+} from '../../CubeIngestCatalog.js';
+import type { CubeLakehouseEnvironment } from '../../CubeLakehouseEnvironment.js';
+import type { CubeProjectCatalog } from '../../CubeProjectCatalog.js';
+import type { CubeServiceCatalog } from '../../CubeServiceCatalog.js';
+import { V1_CubeLakehouseEnvironmentResolver } from './v1/V1_CubeLakehouseEnvironmentResolver.js';
+import { V1_LegendCubeConnectionExplorer } from './v1/V1_LegendCubeConnectionExplorer.js';
+import { V1_LegendCubeDataProductCatalog } from './v1/V1_LegendCubeDataProductCatalog.js';
+import { V1_LegendCubeIngestCatalog } from './v1/V1_LegendCubeIngestCatalog.js';
+import { V1_LegendCubeProjectCatalog } from './v1/V1_LegendCubeProjectCatalog.js';
+import { V1_LegendCubeServiceCatalog } from './v1/V1_LegendCubeServiceCatalog.js';
+import { V1_readCubeIngestDataSets } from './v1/V1_CubeIngestDefinition.js';
+import { V1_serializeCubeLambda } from './v1/V1_CubeLambdaSerializer.js';
+import {
+  V1_readCubeLambda,
+  V1_readCubeValueSpecification,
+} from './v1/V1_CubeLambdaReader.js';
+import { V1_readCubeExpression } from './v1/V1_CubeExpression.js';
 import {
   type V1_CubeEngineConfig,
   V1_LegendCubeEngine,
@@ -31,4 +73,216 @@ export type CubeEngineConfig = V1_CubeEngineConfig;
 export const buildCubeEngine = (
   config: CubeEngineConfig,
   tracerService: TracerService,
-): CubeEngine => new V1_LegendCubeEngine(config, tracerService);
+  options?: {
+    /** Data product cubes run only with one */
+    lakehouseEnvironment?: CubeLakehouseEnvironment | undefined;
+    /** The warehouse the viewer last picked, for a data product cube without its own */
+    getRememberedWarehouse?: (() => string | undefined) | undefined;
+    /** Ingest cubes run only with one, built by `buildCubeIngestCatalog` */
+    ingestCatalog?: CubeIngestCatalog | undefined;
+    /** Dev Settings' engine URL and compression, shared by the host's engine clients (PLAN §11.16) */
+    clientSettings?: CubeEngineClientSettings | undefined;
+    /**
+     * The definitions ingest cubes read, for a host whose catalog isn't
+     * built by `buildCubeIngestCatalog`, e.g. Studio's workspace
+     */
+    ingestDefinitionSource?: CubeIngestDefinitionSource | undefined;
+    /**
+     * The model data product cubes read their project from, for a host whose
+     * data products aren't deployed, e.g. Studio's workspace; the project's
+     * deployed version otherwise
+     */
+    dataProductModelSource?: CubeDataProductModelSource | undefined;
+  },
+): CubeEngine =>
+  new V1_LegendCubeEngine(config, tracerService, {
+    clientSettings: options?.clientSettings,
+    lakehouseEnvironment: options?.lakehouseEnvironment,
+    getRememberedWarehouse: options?.getRememberedWarehouse,
+    dataProductModels: options?.dataProductModelSource,
+    // the catalog reads the definitions the engine types and runs on
+    ingestDefinitions:
+      options?.ingestDefinitionSource ??
+      (options?.ingestCatalog instanceof V1_LegendCubeIngestCatalog
+        ? options.ingestCatalog
+        : undefined),
+  });
+
+/**
+ * The connection explorer of a host that offers direct connections (PLAN
+ * §6.8), over the same engine as its Cube engine
+ */
+export const buildCubeConnectionExplorer = (
+  config: CubeEngineConfig,
+  tracerService: TracerService,
+  clientSettings?: CubeEngineClientSettings,
+): CubeConnectionExplorer =>
+  new V1_LegendCubeConnectionExplorer(config, tracerService, clientSettings);
+
+/** What a host gives Cube to read its deployed data products (PLAN §6.8) */
+export interface CubeLakehouseServices {
+  readonly contractServerClient: LakehouseContractServerClient;
+  readonly depotServerClient: DepotServerClient;
+  readonly getAccessToken: () => string | undefined;
+  /** The viewer, whose lakehouse environment data product runs use */
+  readonly getCurrentUser: () => string;
+  /** The environment the host remembers for the viewer, used before their entitlements' first one */
+  readonly getPreferredEnvironment?: (() => string | undefined) | undefined;
+  /** The marketplace's search API: with it, the source dialog searches there, never reading the lakehouse's whole list */
+  readonly marketplaceServerClient?: MarketplaceServerClient | undefined;
+  /** A deployed data product's page in the host's marketplace; none when the host has no marketplace */
+  readonly getMarketplaceLink?:
+    | ((target: CubeMarketplaceLinkTarget) => string | undefined)
+    | undefined;
+  /**
+   * The stereotype the host's marketplace marks access point groups open to
+   * everyone with; without it, a group with no contract shows no access
+   */
+  readonly enterpriseStereotype?:
+    | { readonly profile: string; readonly value: string }
+    | undefined;
+  /** The lakehouse platform, whose ingest environments the Ingest tab reads (PLAN §6.7) */
+  readonly platformServerClient?: LakehousePlatformServerClient | undefined;
+  /** A client for the ingest servers the platform names: each call names its server */
+  readonly ingestServerClient?: LakehouseIngestServerClient | undefined;
+}
+
+/** The deployed data products of a host with a lakehouse and a depot */
+export const buildCubeDataProductCatalog = (
+  services: CubeLakehouseServices,
+): CubeDataProductCatalog =>
+  new V1_LegendCubeDataProductCatalog(
+    services.contractServerClient,
+    services.depotServerClient,
+    services.getAccessToken,
+    {
+      marketplaceServerClient: services.marketplaceServerClient,
+      marketplaceLink: services.getMarketplaceLink,
+      getCurrentUser: services.getCurrentUser,
+      enterpriseStereotype: services.enterpriseStereotype,
+    },
+  );
+
+/**
+ * The published projects a cube reads Databases from (PLAN §6.3), through
+ * the host's depot. It reads nothing until the source dialog's Project tab
+ * asks
+ */
+export const buildCubeProjectCatalog = (
+  depotServerClient: DepotServerClient,
+): CubeProjectCatalog => new V1_LegendCubeProjectCatalog(depotServerClient);
+
+/**
+ * The services in the engine's registry (PLAN §6.4), read through their own
+ * client, configured as the engine's. The registry isn't in every engine: a
+ * host whose engine has none offers no catalog.
+ */
+export const buildCubeServiceCatalog = (
+  config: CubeEngineConfig,
+  tracerService: TracerService,
+  clientSettings?: CubeEngineClientSettings,
+): CubeServiceCatalog => {
+  const engineClient = new V1_EngineServerClient(config);
+  // every call throws without one
+  engineClient.setTracerService(tracerService);
+  clientSettings?.register(engineClient);
+  return new V1_LegendCubeServiceCatalog(() => engineClient.getServicesInfo());
+};
+
+/** The viewer's lakehouse environment, which the engine needs to run data product cubes */
+export const buildCubeLakehouseEnvironment = (
+  services: CubeLakehouseServices,
+): CubeLakehouseEnvironment =>
+  new V1_CubeLakehouseEnvironmentResolver(
+    services.contractServerClient,
+    services.getAccessToken,
+    services.getCurrentUser,
+    services.getPreferredEnvironment,
+  );
+
+/**
+ * The deployed ingest definitions of a host with a lakehouse platform (PLAN
+ * §6.7), or none without one. It parses definitions with the engine Cube
+ * uses; pass it to `buildCubeEngine` too, so ingest cubes run
+ */
+export const buildCubeIngestCatalog = (
+  config: CubeEngineConfig,
+  tracerService: TracerService,
+  services: CubeLakehouseServices,
+  clientSettings?: CubeEngineClientSettings,
+): CubeIngestCatalog | undefined => {
+  const { platformServerClient, ingestServerClient } = services;
+  if (!platformServerClient || !ingestServerClient) {
+    return undefined;
+  }
+  const engineClient = new V1_EngineServerClient(config);
+  // every call throws without one
+  engineClient.setTracerService(tracerService);
+  clientSettings?.register(engineClient);
+  const environment = new V1_CubeLakehouseEnvironmentResolver(
+    services.contractServerClient,
+    services.getAccessToken,
+    services.getCurrentUser,
+    services.getPreferredEnvironment,
+  );
+  return new V1_LegendCubeIngestCatalog(
+    platformServerClient,
+    ingestServerClient,
+    () => environment.resolveBaseEnvironment(),
+    (code) => engineClient.grammarToJSON_model(code),
+    services.getAccessToken,
+  );
+};
+
+/** The JSON without any `sourceInformation`, at any depth */
+const withoutSourceInformation = (json: unknown): unknown =>
+  Array.isArray(json)
+    ? json.map(withoutSourceInformation)
+    : json !== null && typeof json === 'object'
+      ? Object.fromEntries(
+          Object.entries(json)
+            .filter(([key]) => key !== 'sourceInformation')
+            .map(([key, value]) => [key, withoutSourceInformation(value)]),
+        )
+      : json;
+
+/**
+ * A lambda Cube emitted, as protocol JSON for a host to keep, e.g. in a
+ * Studio ingest definition: plain JSON numbers, and none of the source
+ * information Cube stamps on a lambda to place the engine's errors
+ */
+export const serializeCubeLambdaForHost = (lambda: IR): PlainObject =>
+  withoutSourceInformation(
+    JSON.parse(stringifyLosslessJSON(V1_serializeCubeLambda(lambda))),
+  ) as PlainObject;
+
+/**
+ * The data sets of an ingest definition's content, its protocol JSON, in
+ * order, typed from what it declares; for a host that lists definitions of
+ * its own, e.g. Studio's workspace. Throws when the content can't be read.
+ */
+export const readCubeIngestDataSets = (
+  content: PlainObject,
+): CubeIngestDataSet[] => V1_readCubeIngestDataSets(content);
+
+/**
+ * The IR of a lambda's protocol JSON, Cube's or the engine's grammar's, for
+ * Import Pure (PLAN §11.18): a host's matview, or a pasted lambda. Throws a
+ * `CubeLambdaReadError` naming what Cube can't read.
+ */
+export const readCubeLambdaJson = (json: unknown): IR =>
+  V1_readCubeLambda(json);
+
+/**
+ * How Import Pure stores an expression it reads into a step, and reads one a
+ * step stores (PLAN §11.18): as the Extend and Filter by Expression editors
+ * store the engine's JSON, with no source information and number literals as
+ * their digit strings
+ */
+export const CUBE_EXPRESSION_CODEC: CubeExpressionCodec = {
+  write: (lambda: IR): JsonObject =>
+    V1_readCubeExpression(
+      parseLosslessJSON(stringifyLosslessJSON(V1_serializeCubeLambda(lambda))),
+    ).lambda,
+  read: (json: JsonObject): IR => V1_readCubeValueSpecification(json),
+};

package/src/graph-manager/protocol/pure/v1/V1_CubeDataProductArtifact.ts

@@ -0,0 +1,251 @@
+/**
+ * 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 { Schema } from '@finos/legend-cube';
+import type { PlainObject } from '@finos/legend-shared';
+import {
+  CubeAccessPoint,
+  CubeAccessPointGroup,
+  type CubeAccessPointLocation,
+  type CubeDataProductCandidate,
+  CubeDataProductDescription,
+} from '../../../CubeDataProductCatalog.js';
+import type { CubeResultValue } from '../../../CubeEngine.js';
+import { V1_buildCubeSchema } from './V1_CubeRelationTypeAdapter.js';
+
+// A deployed data product's access points (PLAN §6.8), read from two
+// documents: the product's definition at its deployed version (titles, kinds
+// and parameters) and its deployed artifact (each access point's columns, as
+// the engine typed them when it deployed, and sample rows). Both are read
+// tolerantly: what Cube doesn't know is skipped, and a problem stays on its
+// access point, which is listed but can't be picked. No engine call
+
+/** How many sample rows the preview shows */
+export const V1_CUBE_SAMPLE_ROW_LIMIT = 5;
+
+const LAKEHOUSE_ACCESS_POINT_TYPE = 'lakehouseAccessPoint';
+const MODEL_ACCESS_POINT_GROUP_TYPE = 'modelAccessPointGroup';
+const RELATION_TYPE = 'relationType';
+
+/** Why an access point can't be picked */
+export const V1_CUBE_ACCESS_POINT_REASON = {
+  MODEL_GROUP: 'Model access point groups are not supported yet',
+  NOT_LAKEHOUSE: 'Only Lakehouse access points can be added for now',
+  PARAMETERS: 'It takes parameters, which Cube does not support yet',
+  NOT_DEPLOYED: 'It is not in the deployed artifact',
+  NO_DEFINITION: "Cube couldn't read the data product's definition",
+  NO_RELATION: 'Its result is not a relation',
+  NO_TYPE: 'Its columns are not in the deployed artifact',
+  BAD_MULTIPLICITY: (column: string): string =>
+    `Column "${column}" holds more than one value, which Cube can't show`,
+} as const;
+
+const asObject = (value: unknown): PlainObject =>
+  value && typeof value === 'object' && !Array.isArray(value)
+    ? (value as PlainObject)
+    : {};
+
+const asList = (value: unknown): unknown[] =>
+  Array.isArray(value) ? value : [];
+
+const asString = (value: unknown): string | undefined =>
+  typeof value === 'string' && value.length ? value : undefined;
+
+/** A pair's key: an access point is known by its group and its own id */
+const keyOf = (groupId: string, accessPointId: string): string =>
+  JSON.stringify([groupId, accessPointId]);
+
+/** The artifact's access point implementations, by group and id */
+const readImplementations = (artifact: unknown): Map<string, PlainObject> => {
+  const implementations = new Map<string, PlainObject>();
+  asList(asObject(artifact).accessPointGroups).forEach((group) => {
+    const groupId = asString(asObject(group).id);
+    if (!groupId) {
+      return;
+    }
+    asList(asObject(group).accessPointImplementations).forEach((value) => {
+      const implementation = asObject(value);
+      const id = asString(implementation.id);
+      if (id) {
+        implementations.set(keyOf(groupId, id), implementation);
+      }
+    });
+  });
+  return implementations;
+};
+
+/**
+ * An access point's columns, from its implementation's lambdaGenericType:
+ * the first relation type among its type arguments, whatever the outer type
+ * (a relation, or an ingest relation accessor)
+ */
+const readSchema = (
+  implementation: PlainObject,
+): { schema: Schema } | { reason: string } => {
+  const genericType = asObject(implementation.lambdaGenericType);
+  if (!Object.keys(genericType).length) {
+    return { reason: V1_CUBE_ACCESS_POINT_REASON.NO_TYPE };
+  }
+  const relationType = asList(genericType.typeArguments)
+    .map((argument) => asObject(asObject(argument).rawType))
+    .find((rawType) => rawType._type === RELATION_TYPE);
+  if (!relationType) {
+    return { reason: V1_CUBE_ACCESS_POINT_REASON.NO_RELATION };
+  }
+  for (const column of asList(relationType.columns).map(asObject)) {
+    const multiplicity = asObject(column.multiplicity);
+    if (Object.keys(multiplicity).length && multiplicity.upperBound !== 1) {
+      return {
+        reason: V1_CUBE_ACCESS_POINT_REASON.BAD_MULTIPLICITY(
+          String(column.name),
+        ),
+      };
+    }
+  }
+  try {
+    return { schema: V1_buildCubeSchema(relationType) };
+  } catch (error) {
+    return { reason: error instanceof Error ? error.message : String(error) };
+  }
+};
+
+/** Up to the preview's limit of rows, by the schema's columns; the artifact holds them as text */
+const readSampleRows = (
+  implementation: PlainObject,
+  schema: Schema,
+): CubeResultValue[][] => {
+  const element = asObject(implementation.relationElement);
+  const columns = asList(element.columns).map(String);
+  const positions = schema.columns.map((column) =>
+    columns.indexOf(column.name),
+  );
+  return asList(element.rows)
+    .slice(0, V1_CUBE_SAMPLE_ROW_LIMIT)
+    .map((row) => {
+      const values = asList(asObject(row).values);
+      return positions.map((position) => {
+        const value = position < 0 ? undefined : values[position];
+        return value === undefined || value === null ? null : String(value);
+      });
+    });
+};
+
+/** The stereotype a host's marketplace marks groups open to everyone with */
+export interface V1_CubeEnterpriseStereotype {
+  readonly profile: string;
+  readonly value: string;
+}
+
+/** Whether a group's definition carries the host's enterprise stereotype */
+const isEnterpriseGroup = (
+  group: PlainObject,
+  stereotype: V1_CubeEnterpriseStereotype | undefined,
+): boolean =>
+  stereotype !== undefined &&
+  asList(group.stereotypes)
+    .map(asObject)
+    .some(
+      (each) =>
+        each.profile === stereotype.profile && each.value === stereotype.value,
+    );
+
+/**
+ * A product's access points by group, as its definition lists them. One is
+ * pickable when it is a Lakehouse access point without parameters, outside
+ * a model group, deployed with a relation of columns Cube can read
+ */
+export const V1_readCubeDataProductDescription = (
+  candidate: CubeDataProductCandidate,
+  artifact: unknown,
+  definition: unknown,
+  enterpriseStereotype?: V1_CubeEnterpriseStereotype | undefined,
+): CubeDataProductDescription => {
+  const implementations = readImplementations(artifact);
+  const hasDefinition = Boolean(asObject(definition).accessPointGroups);
+  // without a definition, the artifact's groups are listed, unpickable
+  const groupsJson = hasDefinition
+    ? asList(asObject(definition).accessPointGroups)
+    : asList(asObject(artifact).accessPointGroups).map((group) => ({
+        ...asObject(group),
+        accessPoints: asList(asObject(group).accessPointImplementations),
+      }));
+  const groups = groupsJson
+    .map(asObject)
+    .filter((group) => asString(group.id))
+    .map((group) => {
+      const groupId = group.id as string;
+      const isModelGroup = group._type === MODEL_ACCESS_POINT_GROUP_TYPE;
+      return new CubeAccessPointGroup({
+        id: groupId,
+        title: asString(group.title),
+        isEnterprise: isEnterpriseGroup(group, enterpriseStereotype),
+        accessPoints: asList(group.accessPoints)
+          .map(asObject)
+          .filter((point) => asString(point.id))
+          .map((point) => {
+            const id = point.id as string;
+            const implementation = implementations.get(keyOf(groupId, id));
+            const read = implementation
+              ? readSchema(implementation)
+              : undefined;
+            const schema = read && 'schema' in read ? read.schema : undefined;
+            const disabledReason = !hasDefinition
+              ? V1_CUBE_ACCESS_POINT_REASON.NO_DEFINITION
+              : isModelGroup
+                ? V1_CUBE_ACCESS_POINT_REASON.MODEL_GROUP
+                : point._type !== LAKEHOUSE_ACCESS_POINT_TYPE
+                  ? V1_CUBE_ACCESS_POINT_REASON.NOT_LAKEHOUSE
+                  : asList(asObject(point.func).parameters).length
+                    ? V1_CUBE_ACCESS_POINT_REASON.PARAMETERS
+                    : !implementation
+                      ? V1_CUBE_ACCESS_POINT_REASON.NOT_DEPLOYED
+                      : read && 'reason' in read
+                        ? read.reason
+                        : undefined;
+            return new CubeAccessPoint({
+              id,
+              title: asString(point.title),
+              description:
+                asString(point.description) ??
+                asString(implementation?.description),
+              schema,
+              disabledReason,
+              sampleRows:
+                implementation && schema
+                  ? readSampleRows(implementation, schema)
+                  : [],
+            });
+          }),
+      });
+    });
+  return new CubeDataProductDescription(candidate, groups);
+};
+
+/** A saved source's schema, from the product's description, or why it has none */
+export const V1_findCubeAccessPointSchema = (
+  description: CubeDataProductDescription,
+  location: CubeAccessPointLocation,
+): Schema | string => {
+  const accessPoint = description.groups
+    .find((group) => group.id === location.accessPointGroup)
+    ?.accessPoints.find((point) => point.id === location.accessPoint);
+  if (!accessPoint) {
+    return `The data product has no access point "${location.accessPoint}" in group "${location.accessPointGroup}"`;
+  }
+  return accessPoint.isPickable
+    ? (accessPoint.schema as Schema)
+    : (accessPoint.disabledReason ?? V1_CUBE_ACCESS_POINT_REASON.NO_TYPE);
+};

package/src/graph-manager/protocol/pure/v1/V1_CubeDataProductModel.ts

@@ -0,0 +1,107 @@
+/**
+ * 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 { IR } from '@finos/legend-cube';
+import type { PlainObject } from '@finos/legend-shared';
+import {
+  CUBE_DATA_PRODUCT_RUNTIME_PATH,
+  type CubeDataProductProject,
+} from '../../../CubeDataProduct.js';
+import { CUBE_LAKEHOUSE_RUNTIME_KIND } from '../../../CubeLakehouseRuntime.js';
+
+// The models a data product cube's engine calls run on (PLAN §6.8), built for
+// each call and never saved: the project at its saved version, and for a run
+// a lakehouse runtime at Cube's fixed path, whose environment and warehouse
+// are resolved for the viewer
+
+const splitPath = (path: string): { package: string; name: string } => {
+  const index = path.lastIndexOf('::');
+  return { package: path.slice(0, index), name: path.slice(index + 2) };
+};
+
+/** The project at the version its data products were deployed from: never a moving alias */
+const pointerOf = (project: CubeDataProductProject): PlainObject => ({
+  _type: 'pointer',
+  sdlcInfo: {
+    _type: 'alloy',
+    baseVersion: 'latest',
+    version: project.versionId,
+    packageableElementPointers: [],
+    groupId: project.groupId,
+    artifactId: project.artifactId,
+  },
+});
+
+/** Whether a lambda reads a data product's access point, anywhere in it */
+export const V1_hasCubeDataProductAccessor = (ir: IR): boolean => {
+  const visit = (value: unknown): boolean => {
+    if (Array.isArray(value)) {
+      return value.some(visit);
+    }
+    if (!value || typeof value !== 'object') {
+      return false;
+    }
+    const node = value as PlainObject;
+    if (node.k === 'dataProductAccessor') {
+      return true;
+    }
+    return node.k !== 'raw' && Object.values(node).some(visit);
+  };
+  return visit(ir);
+};
+
+/**
+ * The model typing runs on: the project alone, with no runtime; the host's
+ * model of it when it has one, e.g. Studio's workspace
+ */
+export const V1_buildCubeDataProductTypingContext = (
+  project: CubeDataProductProject,
+  projectModel?: PlainObject | undefined,
+): PlainObject => projectModel ?? pointerOf(project);
+
+/**
+ * The model a run runs on: the project (the host's model of it, when it has
+ * one), then a model holding only the lakehouse runtime at Cube's fixed path,
+ * with the viewer's environment and the warehouse, always given
+ */
+export const V1_buildCubeDataProductExecutionContext = (
+  project: CubeDataProductProject,
+  environment: string,
+  warehouse: string,
+  projectModel?: PlainObject | undefined,
+): PlainObject => ({
+  _type: 'combination',
+  contexts: [
+    projectModel ?? pointerOf(project),
+    {
+      _type: 'data',
+      elements: [
+        {
+          _type: 'runtime',
+          ...splitPath(CUBE_DATA_PRODUCT_RUNTIME_PATH),
+          runtimeValue: {
+            _type: CUBE_LAKEHOUSE_RUNTIME_KIND,
+            connectionStores: [],
+            connections: [],
+            mappings: [],
+            environment,
+            warehouse,
+          },
+        },
+      ],
+    },
+  ],
+});