@finos/legend-cube-builder 0.0.2 → 0.0.4

package/src/graph-manager/protocol/pure/v1/__test-utils__/V1_CubeDataProductFixtures.ts

@@ -0,0 +1,337 @@
+/**
+ * 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 { PlainObject } from '@finos/legend-shared';
+
+// A deployed data product's two documents, as the depot serves them, for
+// Cube's tests. Their shapes are copied from legend-graph's
+// TEST_DATA__DataProductAnalysis.ts (the artifact) and
+// legend-extension-dsl-data-product's TEST_DATA__LakehouseDataProducts.ts
+// (the definition); nothing is imported from another package's test utils
+
+const P = 'meta::pure::precisePrimitives::';
+
+/** A relation column, as the engine types it */
+export const V1_TEST__relationColumn = (
+  name: string,
+  fullPath: string,
+  params: number[] = [],
+  lowerBound = 1,
+): PlainObject => ({
+  name,
+  genericType: {
+    rawType: { _type: 'packageableType', fullPath },
+    typeArguments: [],
+    multiplicityArguments: [],
+    typeVariableValues: params.map((value) => ({ _type: 'integer', value })),
+  },
+  multiplicity: { lowerBound, upperBound: 1 },
+});
+
+/** A lambdaGenericType: a relation of these columns, under the outer type given */
+export const V1_TEST__relationGenericType = (
+  columns: PlainObject[],
+  outer = 'meta::pure::metamodel::relation::Relation',
+): PlainObject => ({
+  rawType: { _type: 'packageableType', fullPath: outer },
+  typeArguments: [
+    {
+      rawType: { _type: 'relationType', columns },
+      typeArguments: [],
+      multiplicityArguments: [],
+      typeVariableValues: [],
+    },
+  ],
+  multiplicityArguments: [],
+  typeVariableValues: [],
+});
+
+const lambda = (parameters: PlainObject[] = []): PlainObject => ({
+  _type: 'lambda',
+  body: [],
+  parameters,
+});
+
+const ORDERS_COLUMNS = [
+  V1_TEST__relationColumn('ORDER_ID', `${P}Int`),
+  V1_TEST__relationColumn('REGION', `${P}Varchar`, [200], 0),
+  V1_TEST__relationColumn('AMOUNT', `${P}Numeric`, [10, 2], 0),
+];
+
+/** The orders product's definition, as its project holds it at the deployed version */
+export const V1_TEST__ORDERS_DEFINITION: PlainObject = {
+  _type: 'dataProduct',
+  package: 'sales::products',
+  name: 'OrdersProduct',
+  title: 'Orders Product',
+  accessPointGroups: [
+    {
+      _type: 'defaultAccessPointGroup',
+      id: 'core',
+      title: 'Core',
+      accessPoints: [
+        {
+          _type: 'lakehouseAccessPoint',
+          id: 'daily_orders',
+          title: 'Daily orders',
+          description: 'One row per order',
+          targetEnvironment: 'Snowflake',
+          func: lambda(),
+        },
+        {
+          _type: 'lakehouseAccessPoint',
+          id: 'orders_as_of',
+          title: 'Orders as of a date',
+          targetEnvironment: 'Snowflake',
+          func: lambda([{ _type: 'var', name: 'asOf' }]),
+        },
+        {
+          _type: 'functionAccessPoint',
+          id: 'order_function',
+          func: lambda(),
+        },
+        {
+          _type: 'lakehouseAccessPoint',
+          id: 'events',
+          title: 'Order events',
+          targetEnvironment: 'Snowflake',
+          func: lambda(),
+        },
+        {
+          _type: 'lakehouseAccessPoint',
+          id: 'scalar',
+          targetEnvironment: 'Snowflake',
+          func: lambda(),
+        },
+        {
+          _type: 'lakehouseAccessPoint',
+          id: 'tags',
+          targetEnvironment: 'Snowflake',
+          func: lambda(),
+        },
+        {
+          _type: 'lakehouseAccessPoint',
+          id: 'nested',
+          targetEnvironment: 'Snowflake',
+          func: lambda(),
+        },
+        {
+          _type: 'lakehouseAccessPoint',
+          id: 'undeployed',
+          targetEnvironment: 'Snowflake',
+          func: lambda(),
+        },
+        { _type: 'laterAccessPoint', id: 'later', func: lambda() },
+      ],
+    },
+    {
+      _type: 'defaultAccessPointGroup',
+      id: 'reference',
+      title: 'Reference',
+      accessPoints: [
+        {
+          _type: 'lakehouseAccessPoint',
+          id: 'daily_orders',
+          title: 'Daily customers',
+          targetEnvironment: 'Snowflake',
+          func: lambda(),
+        },
+      ],
+    },
+    {
+      _type: 'modelAccessPointGroup',
+      id: 'model',
+      accessPoints: [
+        {
+          _type: 'lakehouseAccessPoint',
+          id: 'modelled',
+          targetEnvironment: 'Snowflake',
+          func: lambda(),
+        },
+      ],
+    },
+  ],
+};
+
+/** The orders product's deployed artifact */
+export const V1_TEST__ORDERS_ARTIFACT: PlainObject = {
+  dataProduct: {
+    path: 'sales::products::OrdersProduct',
+    deploymentId: 'deployment-1234',
+    title: 'Orders Product',
+    dataProductType: { _type: 'laterDataProductType' },
+  },
+  accessPointGroups: [
+    {
+      id: 'core',
+      accessPointImplementations: [
+        {
+          id: 'daily_orders',
+          description: 'Deployed daily orders',
+          resourceBuilder: [
+            { _type: 'functionAccessPoint', functionGrammar: '|1' },
+          ],
+          lambdaGenericType: V1_TEST__relationGenericType(ORDERS_COLUMNS),
+          relationElement: {
+            columns: ['REGION', 'ORDER_ID', 'AMOUNT'],
+            paths: [],
+            rows: [1, 2, 3, 4, 5, 6, 7].map((id) => ({
+              values: [id % 2 ? 'EMEA' : 'APAC', String(id), `${id}.50`],
+            })),
+          },
+        },
+        {
+          id: 'orders_as_of',
+          lambdaGenericType: V1_TEST__relationGenericType(ORDERS_COLUMNS),
+        },
+        {
+          id: 'order_function',
+          lambdaGenericType: V1_TEST__relationGenericType(ORDERS_COLUMNS),
+        },
+        {
+          id: 'events',
+          // as artifacts were generated before it became a list
+          resourceBuilder: {
+            _type: 'functionAccessPoint',
+            functionGrammar: '|1',
+          },
+          lambdaGenericType: V1_TEST__relationGenericType(
+            [
+              V1_TEST__relationColumn('EVENT_ID', 'Integer'),
+              V1_TEST__relationColumn('AT', `${P}Timestamp`),
+              V1_TEST__relationColumn('DAY', 'StrictDate', [], 0),
+              V1_TEST__relationColumn('RATE', `${P}Float4`, [], 0),
+              V1_TEST__relationColumn(
+                'PAYLOAD',
+                'meta::pure::metamodel::variant::Variant',
+                [],
+                0,
+              ),
+              // a column with nothing but its type
+              {
+                name: 'NOTE',
+                genericType: {
+                  rawType: { _type: 'packageableType', fullPath: 'String' },
+                },
+                multiplicity: { lowerBound: 0, upperBound: 1 },
+              },
+            ],
+            'meta::external::ingest::accessor::IngestRelationAccessor',
+          ),
+        },
+        {
+          id: 'scalar',
+          lambdaGenericType: {
+            rawType: { _type: 'packageableType', fullPath: 'String' },
+          },
+        },
+        {
+          id: 'tags',
+          lambdaGenericType: V1_TEST__relationGenericType([
+            // no upper bound: many values
+            {
+              name: 'TAG',
+              genericType: {
+                rawType: { _type: 'packageableType', fullPath: 'String' },
+              },
+              multiplicity: { lowerBound: 0 },
+            },
+          ]),
+        },
+        {
+          id: 'nested',
+          lambdaGenericType: V1_TEST__relationGenericType([
+            {
+              name: 'INNER',
+              genericType: { rawType: { _type: 'relationType', columns: [] } },
+              multiplicity: { lowerBound: 1, upperBound: 1 },
+            },
+          ]),
+        },
+        {
+          id: 'later',
+          lambdaGenericType: V1_TEST__relationGenericType(ORDERS_COLUMNS),
+        },
+        { id: 'only_in_artifact' },
+      ],
+    },
+    {
+      id: 'reference',
+      accessPointImplementations: [
+        {
+          id: 'daily_orders',
+          lambdaGenericType: V1_TEST__relationGenericType([
+            V1_TEST__relationColumn('CUSTOMER_ID', `${P}Varchar`, [10]),
+          ]),
+        },
+      ],
+    },
+    {
+      _type: 'modelAccessPointGroup',
+      id: 'model',
+      accessPointImplementations: [
+        {
+          id: 'modelled',
+          lambdaGenericType: V1_TEST__relationGenericType(ORDERS_COLUMNS),
+        },
+      ],
+    },
+  ],
+};
+
+/** A product of Lakehouse access points only, with no model group: definition and artifact */
+export const V1_TEST__LAKEHOUSE_ONLY_DEFINITION: PlainObject = {
+  _type: 'dataProduct',
+  package: 'sales::products',
+  name: 'CustomersProduct',
+  accessPointGroups: [
+    {
+      _type: 'defaultAccessPointGroup',
+      id: 'customers',
+      accessPoints: [
+        {
+          _type: 'lakehouseAccessPoint',
+          id: 'all_customers',
+          targetEnvironment: 'Snowflake',
+          func: lambda(),
+        },
+      ],
+    },
+  ],
+};
+
+export const V1_TEST__LAKEHOUSE_ONLY_ARTIFACT: PlainObject = {
+  dataProduct: {
+    path: 'sales::products::CustomersProduct',
+    deploymentId: 'deployment-5678',
+  },
+  accessPointGroups: [
+    {
+      id: 'customers',
+      accessPointImplementations: [
+        {
+          id: 'all_customers',
+          resourceBuilder: [
+            { _type: 'functionAccessPoint', functionGrammar: '|1' },
+          ],
+          lambdaGenericType: V1_TEST__relationGenericType([
+            V1_TEST__relationColumn('CUSTOMER_ID', `${P}Varchar`, [10]),
+          ]),
+        },
+      ],
+    },
+  ],
+};

package/src/graph-manager/protocol/pure/v1/__test-utils__/V1_CubeDataProductSearchFixtures.ts

@@ -0,0 +1,206 @@
+/**
+ * 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 { PlainObject } from '@finos/legend-shared';
+
+// A page of the marketplace's Lakehouse Access search, and the same product
+// as a page of the lakehouse's lite list, for Cube's tests. The search rows
+// and page are copied from legend-server-marketplace's
+// DataProductSearchResult.test.ts and legend-application-marketplace's
+// TEST_DATA__LakehouseSearchResultData.ts (createMockPaginatedResult,
+// mockLakehouseAccessSearchResultResponse); the lite page from
+// legend-server-lakehouse's LakehouseContractServerClient.test.ts. Nothing is
+// imported from another package's test utils
+
+const ORDERS_SEARCH_ORIGIN: PlainObject = {
+  _type: 'SdlcDeployment',
+  groupId: 'com.example.sales',
+  artifactId: 'orders-products',
+  versionId: '1.4.0',
+  path: 'sales::products::OrdersProduct',
+};
+
+/** A lakehouse search row; its details as given, over the orders product's, an undefined one left out */
+const searchRow = (details: Record<string, unknown>): PlainObject => {
+  const fields: Record<string, unknown> = {
+    _type: 'lakehouse',
+    deploymentId: 1234,
+    producerEnvironmentName: 'sales-producer',
+    producerEnvironmentType: 'PRODUCTION',
+    origin: ORDERS_SEARCH_ORIGIN,
+    ...details,
+  };
+  return {
+    dataProductTitle: `${String(details.dataProductId)} title`,
+    dataProductDescription: `About ${String(details.dataProductId)}`,
+    tags1: [],
+    tags2: [],
+    tag_score: 0,
+    similarity: 0.9,
+    dataProductSource: 'Internal',
+    dataProductDetails: Object.fromEntries(
+      Object.entries(fields).filter(([, value]) => value !== undefined),
+    ),
+  };
+};
+
+/** The orders product deployed to Production, as a search row: no description */
+export const V1_TEST__SEARCH_ROW_ORDERS: PlainObject = {
+  ...searchRow({ dataProductId: 'ORDERS_PRODUCT' }),
+  dataProductTitle: 'Orders Product',
+  dataProductDescription: null,
+};
+
+/** A product whose class comes in 'Production' casing, as some deployments send it */
+export const V1_TEST__SEARCH_ROW_CASED: PlainObject = searchRow({
+  dataProductId: 'CASED_PRODUCT',
+  producerEnvironmentType: 'Production',
+});
+
+/** Rows the search's serializer reads, but Cube doesn't list: one of each kind */
+export const V1_TEST__UNLISTED_SEARCH_ROWS: readonly PlainObject[] = [
+  searchRow({
+    dataProductId: 'ADHOC_PRODUCT',
+    origin: { _type: 'AdHocDeployment' },
+  }),
+  searchRow({ dataProductId: 'NULL_ORIGIN_PRODUCT', origin: null }),
+  searchRow({ dataProductId: 'NO_ORIGIN_PRODUCT', origin: undefined }),
+  searchRow({
+    dataProductId: 'NO_GROUP_PRODUCT',
+    origin: { ...ORDERS_SEARCH_ORIGIN, groupId: null },
+  }),
+  searchRow({
+    dataProductId: 'NO_PATH_PRODUCT',
+    origin: { ...ORDERS_SEARCH_ORIGIN, path: '' },
+  }),
+  searchRow({
+    dataProductId: 'NO_DEPLOYMENT_PRODUCT',
+    deploymentId: undefined,
+  }),
+  searchRow({ dataProductId: '' }),
+  searchRow({
+    dataProductId: 'PARALLEL_PRODUCT',
+    producerEnvironmentType: 'PRODUCTION_PARALLEL',
+  }),
+  searchRow({
+    dataProductId: 'NO_CLASS_PRODUCT',
+    producerEnvironmentType: undefined,
+  }),
+  {
+    dataProductTitle: 'Legacy Data Product',
+    dataProductDescription: 'This is a legacy Data Product',
+    tags1: [],
+    tags2: [],
+    tag_score: 0,
+    similarity: 0,
+    dataProductDetails: {
+      _type: 'legacy',
+      groupId: 'com.example.legacy',
+      artifactId: 'legacy-data-product',
+      versionId: '2.0.0',
+      path: 'test::Legacy_Data_Product',
+    },
+  },
+  {
+    dataProductTitle: null,
+    dataProductDescription: null,
+    tags1: [],
+    tags2: [],
+    tag_score: 0,
+    similarity: 0,
+    dataProductDetails: {
+      _type: 'error',
+      message: 'Could not resolve data product',
+    },
+  },
+];
+
+/** Rows of a type the search's serializer doesn't know, on which it throws */
+export const V1_TEST__UNREADABLE_SEARCH_ROWS: readonly PlainObject[] = [
+  searchRow({
+    dataProductId: 'UNKNOWN_ORIGIN_PRODUCT',
+    origin: { _type: 'FutureDeployment' },
+  }),
+  {
+    ...searchRow({ dataProductId: 'UNKNOWN_DETAILS_PRODUCT' }),
+    dataProductDetails: { _type: 'future', dataProductId: 'FUTURE' },
+  },
+];
+
+/** A Lakehouse Access answer: one page of the rows given */
+export const V1_TEST__searchPage = (
+  rows: readonly PlainObject[],
+  totalCount = rows.length,
+): PlainObject => ({
+  results: rows,
+  metadata: {
+    total_count: totalCount,
+    num_pages: 1,
+    page_size: 100,
+    page_number: 1,
+    next_page_number: null,
+    prev_page_number: null,
+    lakehouse_count: rows.length,
+    legacy_count: 0,
+  },
+  as_of_time: '2026-01-27T00:00:00.000Z',
+});
+
+/** Every kind of row, the ones Cube can't read among the ones it lists */
+export const V1_TEST__SEARCH_PAGE: PlainObject = V1_TEST__searchPage([
+  V1_TEST__SEARCH_ROW_ORDERS,
+  ...V1_TEST__UNREADABLE_SEARCH_ROWS,
+  ...V1_TEST__UNLISTED_SEARCH_ROWS,
+  V1_TEST__SEARCH_ROW_CASED,
+]);
+
+/** The rows whose types the search's serializer knows, which it reads as a whole page */
+export const V1_TEST__SEARCH_PAGE_KNOWN_SHAPES: PlainObject =
+  V1_TEST__searchPage([
+    V1_TEST__SEARCH_ROW_ORDERS,
+    ...V1_TEST__UNLISTED_SEARCH_ROWS,
+    V1_TEST__SEARCH_ROW_CASED,
+  ]);
+
+/** The orders product deployed to Production, as the lakehouse's lite list gives it: no description */
+export const V1_TEST__LITE_PAGE_ORDERS: PlainObject = {
+  liteDataProductsResponse: {
+    dataProducts: [
+      {
+        id: 'ORDERS_PRODUCT',
+        deploymentId: 1234,
+        title: 'Orders Product',
+        description: null,
+        origin: {
+          type: 'SdlcDeployment',
+          group: 'com.example.sales',
+          artifact: 'orders-products',
+          version: '1.4.0',
+        },
+        fullPath: 'sales::products::OrdersProduct',
+        lakehouseEnvironment: {
+          producerEnvironmentName: 'sales-producer',
+          type: 'PRODUCTION',
+        },
+      },
+    ],
+  },
+  paginationMetadataRecord: {
+    hasNextPage: false,
+    size: 1000,
+    lastValuesMap: { id: 'ORDERS_PRODUCT', deployment_id: 1234 },
+  },
+};

package/src/graph-manager/protocol/pure/v1/__test-utils__/V1_CubeEngineTestUtils.ts

@@ -15,7 +15,10 @@
  */
 
 import { jest } from '@jest/globals';
-import { ENGINE_TEST_SUPPORT__grammarToJSON_model } from '@finos/legend-graph/test';
+import {
+  ENGINE_TEST_SUPPORT__grammarToJSON_model,
+  ENGINE_TEST_SUPPORT_API_URL,
+} from '@finos/legend-graph/test';
 import {
   NetworkClientError,
   type PlainObject,
@@ -24,9 +27,12 @@ import {
 import { AxiosError } from 'axios';
 import {
   CUBE_ENGINE_TEST__execute,
+  CUBE_ENGINE_TEST__generatePlan,
+  CUBE_ENGINE_TEST__grammarToJson_valueSpecification,
   CUBE_ENGINE_TEST__jsonToGrammar_lambda,
   CUBE_ENGINE_TEST__lambdaRelationTypeBatch,
 } from '../../../../../__test-utils__/CubeEngineTestSupport.js';
+import { CUBE_ENGINE_TEST__schemaExploration } from '../../../../../__test-utils__/CubeConnectionTestSupport.js';
 import { V1_LegendCubeEngine } from '../V1_LegendCubeEngine.js';
 
 // The real Cube engine, its client's calls routed to the engine on :6300 by
@@ -40,7 +46,7 @@ const clientError = (status: number, payload: unknown): NetworkClientError =>
     {
       status,
       statusText: String(status),
-      url: 'http://localhost:6300/api',
+      url: ENGINE_TEST_SUPPORT_API_URL,
     } as Response,
     payload as NetworkClientError['payload'],
   );
@@ -69,12 +75,15 @@ const rethrowAsClientError = (error: unknown): never => {
 export const V1_createEngineBackedCubeEngine = (): {
   engine: V1_LegendCubeEngine;
   calls: Record<
-    'grammarToJSON_model' | 'batchLambdasRelationType' | 'runQuery',
+    | 'grammarToJSON_model'
+    | 'batchLambdasRelationType'
+    | 'runQuery'
+    | 'buildDatabase',
     jest.Mock
   >;
 } => {
   const engine = new V1_LegendCubeEngine(
-    { baseUrl: 'http://localhost:6300/api' },
+    { baseUrl: ENGINE_TEST_SUPPORT_API_URL },
     new TracerService(),
   );
   const { client } = engine;
@@ -105,6 +114,40 @@ export const V1_createEngineBackedCubeEngine = (): {
       }
       return response as unknown as Response;
     });
+  // a direct-connection cube reads its tables through schema exploration
+  const buildDatabase = jest
+    .spyOn(client, 'buildDatabase')
+    .mockImplementation(async (input) =>
+      CUBE_ENGINE_TEST__schemaExploration(input).catch(rethrowAsClientError),
+    );
+  // an Extend's planned lambda (PLAN §11.7)
+  jest
+    .spyOn(client, 'generatePlan')
+    .mockImplementation(
+      async (input) =>
+        (await CUBE_ENGINE_TEST__generatePlan(input).catch(
+          rethrowAsClientError,
+        )) as never,
+    );
+  // an Extend's expression, read unread as the adapter asks; every other
+  // request goes on as it would, and fails as any network call in a test
+  const post = client.postWithTracing.bind(client);
+  jest
+    .spyOn(client, 'postWithTracing')
+    .mockImplementation(async (...args: Parameters<typeof post>) => {
+      const [, url, data, , , parameters] = args;
+      if (!url.endsWith('/grammar/grammarToJson/valueSpecification')) {
+        return post(...args);
+      }
+      const response = await CUBE_ENGINE_TEST__grammarToJson_valueSpecification(
+        data as string,
+        String(parameters?.sourceId),
+      );
+      if (!response.ok) {
+        throw clientError(response.status, parseOrText(await response.text()));
+      }
+      return response as never;
+    });
   jest
     .spyOn(client, 'JSONToGrammar_lambda')
     .mockImplementation(async (lambda, renderStyle) =>
@@ -119,6 +162,7 @@ export const V1_createEngineBackedCubeEngine = (): {
       batchLambdasRelationType:
         batchLambdasRelationType as unknown as jest.Mock,
       runQuery: runQuery as unknown as jest.Mock,
+      buildDatabase: buildDatabase as unknown as jest.Mock,
     },
   };
 };

package/src/index.ts

@@ -20,14 +20,34 @@ export {
 } from './__lib__/LegendCubeCommand.js';
 export { LEGEND_CUBE_TEST_ID } from './__lib__/LegendCubeTesting.js';
 export { CubeEditor } from './components/CubeEditor.js';
+export {
+  type CubeAccessPointEntry,
+  type CubeEntrySource,
+  formatCubeAccessPointEntryId,
+} from './stores/CubeEntrySource.js';
 
+export * from './graph-manager/CubeConnectionExplorer.js';
+export * from './graph-manager/CubeDataProduct.js';
+export * from './graph-manager/CubeDataProductCatalog.js';
+export * from './graph-manager/CubeIngest.js';
+export * from './graph-manager/CubeIngestCatalog.js';
 export * from './graph-manager/CubeEngine.js';
+export * from './graph-manager/CubeProject.js';
+export * from './graph-manager/CubeProjectCatalog.js';
 export { getRuntimesForDatabase } from './graph-manager/CubeModelOutlineHelper.js';
 export {
+  buildCubeConnectionExplorer,
+  buildCubeDataProductCatalog,
+  buildCubeIngestCatalog,
   buildCubeEngine,
+  buildCubeLakehouseEnvironment,
+  buildCubeProjectCatalog,
   type CubeEngineConfig,
+  type CubeLakehouseServices,
 } from './graph-manager/protocol/pure/CubeEngineBuilder.js';
+export type { CubeLakehouseEnvironment } from './graph-manager/CubeLakehouseEnvironment.js';
 export type { CubeHost } from './stores/CubeHost.js';
+export { getCubeRememberedWarehouse } from './stores/CubeDataProductWarehouse.js';
 export {
   BUNDLED_MODELS,
   type BundledModel,