@finos/legend-application-data-cube 0.7.5 → 0.7.6

package/src/stores/LegendDataCubeDataCubeEngine.ts

@@ -163,6 +163,7 @@ import {
   LAKEHOUSE_CONSUMER_DATA_CUBE_SOURCE_TYPE,
   LakehouseConsumerDataCubeSource,
   RawLakehouseConsumerDataCubeSource,
+  RawLakehouseSdlcOrigin,
 } from './model/LakehouseConsumerDataCubeSource.js';
 
 export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
@@ -172,6 +173,7 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
   private readonly _graphManager: V1_PureGraphManager;
   private readonly _duckDBEngine: LegendDataCubeDuckDBEngine;
   private _ingestDefinition: PlainObject | undefined;
+  private _adhocDataProductGraphGrammar: string | undefined;
 
   constructor(
     application: LegendDataCubeApplicationStore,
@@ -394,7 +396,6 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
           warehouse: rawSource.warehouse,
           path: rawSource.paths[0],
           accessPoint: rawSource.paths[1],
-          dpCoordinates: rawSource.dpCoordinates,
         },
         sourceType: source._type,
       };
@@ -746,7 +747,9 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
         source.environment = rawSource.environment;
         source.paths = rawSource.paths;
         source.warehouse = rawSource.warehouse;
-        source.dpCoordinates = rawSource.dpCoordinates;
+        if (rawSource.origin instanceof RawLakehouseSdlcOrigin) {
+          source.dpCoordinates = rawSource.origin.dpCoordinates;
+        }
 
         //TODO: add support for parameters
         try {
@@ -1267,6 +1270,10 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
     this._ingestDefinition = ingestDefinition;
   }
 
+  registerAdhocDataProductGraphGrammar(fullGraphGrammar: string | undefined) {
+    this._adhocDataProductGraphGrammar = fullGraphGrammar;
+  }
+
   // ---------------------------------- CACHING --------------------------------------
 
   override async initializeCache(
@@ -1800,12 +1807,21 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
     rawSource: RawLakehouseConsumerDataCubeSource,
     source: LakehouseConsumerDataCubeSource,
   ) {
-    const pmcd = await this._depotServerClient.getPureModelContextData(
-      rawSource.dpCoordinates.groupId,
-      rawSource.dpCoordinates.artifactId,
-      rawSource.dpCoordinates.versionId,
-      true,
-    );
+    let pmcd: PlainObject<V1_PureModelContextData> | undefined;
+    if (rawSource.origin instanceof RawLakehouseSdlcOrigin) {
+      const coordinates = guaranteeNonNullable(rawSource.origin.dpCoordinates);
+      pmcd = await this._depotServerClient.getPureModelContextData(
+        coordinates.groupId,
+        coordinates.artifactId,
+        coordinates.versionId,
+        true,
+      );
+    } else {
+      pmcd = await this.parseCompatibleModel(
+        guaranteeNonNullable(this._adhocDataProductGraphGrammar),
+      );
+    }
+
     const deserializedPMCD = guaranteeType(
       V1_deserializePureModelContext(pmcd),
       V1_PureModelContextData,

package/src/stores/builder/LegendDataCubeBuilderStore.tsx

@@ -77,6 +77,8 @@ import type {
 } from '@finos/legend-server-lakehouse';
 import { LAKEHOUSE_PRODUCER_DATA_CUBE_SOURCE_TYPE } from '../model/LakehouseProducerDataCubeSource.js';
 import { LakehouseProducerDataCubeSourceLoaderState } from './source/LakehouseProducerDataCubeSourceLoaderState.js';
+import { LAKEHOUSE_CONSUMER_DATA_CUBE_SOURCE_TYPE } from '../model/LakehouseConsumerDataCubeSource.js';
+import { LakehouseConsumerDataCubeSourceLoaderState } from './source/LakehouseConsumerDataCubeSourceLoaderState.js';
 
 export class LegendDataCubeBuilderState {
   readonly uuid = uuid();
@@ -359,6 +361,16 @@ export class LegendDataCubeBuilderStore {
           onSuccess,
           onError,
         );
+      case LAKEHOUSE_CONSUMER_DATA_CUBE_SOURCE_TYPE:
+        return new LakehouseConsumerDataCubeSourceLoaderState(
+          this.application,
+          this.engine,
+          this.alertService,
+          sourceData,
+          persistentDataCube,
+          onSuccess,
+          onError,
+        );
       default:
         throw new UnsupportedOperationError(
           `Can't create source loader for unsupported type '${sourceData._type}'`,

package/src/stores/builder/source/LakehouseConsumerDataCubeSourceBuilderState.ts

@@ -41,19 +41,32 @@ import {
   type V1_EntitlementsDataProductLite,
   type V1_EntitlementsDataProductLiteResponse,
   V1_entitlementsDataProductDetailsResponseToDataProductDetails,
+  V1_DataProductOriginType,
+  V1_AdHocDeploymentDataProductOrigin,
+  type V1_EntitlementsDataProductDetails,
 } from '@finos/legend-graph';
-import { RawLakehouseConsumerDataCubeSource } from '../../model/LakehouseConsumerDataCubeSource.js';
+import {
+  LakehouseEnvironmentType,
+  RawLakehouseAdhocOrigin,
+  RawLakehouseConsumerDataCubeSource,
+  RawLakehouseSdlcOrigin,
+} from '../../model/LakehouseConsumerDataCubeSource.js';
 
 export class LakehouseConsumerDataCubeSourceBuilderState extends LegendDataCubeSourceBuilderState {
   warehouse: string | undefined;
   selectedDataProduct: string | undefined;
   selectedAccessPoint: string | undefined;
   paths: string[] = [];
+  allEnvironments: string[] = [];
   environments: string[] = [];
   selectedEnvironment: string | undefined;
   dataProducts: V1_EntitlementsDataProductLite[] = [];
   accessPoints: string[] = [];
   dpCoordinates: VersionedProjectData | undefined;
+  origin: string | undefined;
+  fullGraphGrammar: string | undefined;
+
+  dataProductDetails: V1_EntitlementsDataProductDetails[] = [];
 
   DEFAULT_CONSUMER_WAREHOUSE = 'LAKEHOUSE_CONSUMER_DEFAULT_WH';
 
@@ -114,6 +127,10 @@ export class LakehouseConsumerDataCubeSourceBuilderState extends LegendDataCubeS
     this.environments = environments;
   }
 
+  setAllEnvironments(environments: string[]) {
+    this.allEnvironments = environments;
+  }
+
   setSelectedAccessPoint(accessPoint: string | undefined) {
     this.selectedAccessPoint = accessPoint;
   }
@@ -138,51 +155,114 @@ export class LakehouseConsumerDataCubeSourceBuilderState extends LegendDataCubeS
     }
   }
 
-  async fetchAccessPoints(access_token?: string) {
+  async fetchDataProduct(access_token?: string) {
     this.resetEnvironment();
 
     const selectedDp = guaranteeNonNullable(this.selectedDataProduct);
-    const dataProducts =
+    this.dataProductDetails =
       V1_entitlementsDataProductDetailsResponseToDataProductDetails(
         await this._contractServerClient.getDataProduct(
           selectedDp.split('::').pop() ?? '',
           access_token,
         ),
       );
-    if (dataProducts.length > 0) {
-      const dataProduct =
-        dataProducts.length === 1
-          ? dataProducts.at(0)
-          : dataProducts
-              .filter(
-                (dp) =>
-                  Boolean(dp.lakehouseEnvironment) &&
-                  dp.lakehouseEnvironment?.type ===
-                    V1_EntitlementsLakehouseEnvironmentType.PRODUCTION,
-              )
-              .at(0);
-      if (dataProduct?.origin instanceof V1_SdlcDeploymentDataProductOrigin) {
-        const versionedData = new VersionedProjectData();
-        versionedData.groupId = dataProduct.origin.group;
-        versionedData.artifactId = dataProduct.origin.artifact;
-        versionedData.versionId = dataProduct.origin.version;
-        this.dpCoordinates = versionedData;
+
+    const filterEnvironments = (
+      type: V1_EntitlementsLakehouseEnvironmentType,
+      environments: string[],
+    ): string[] => {
+      switch (type) {
+        case V1_EntitlementsLakehouseEnvironmentType.PRODUCTION:
+          return environments.filter(
+            (env) =>
+              !env.includes(LakehouseEnvironmentType.PRODUCTION_PARALLEL) &&
+              !env.includes(LakehouseEnvironmentType.DEVELOPMENT),
+          );
+        case V1_EntitlementsLakehouseEnvironmentType.PRODUCTION_PARALLEL:
+          return environments.filter((env) =>
+            env.includes(LakehouseEnvironmentType.PRODUCTION_PARALLEL),
+          );
+        case V1_EntitlementsLakehouseEnvironmentType.DEVELOPMENT:
+          return environments.filter((env) =>
+            env.includes(LakehouseEnvironmentType.DEVELOPMENT),
+          );
+        default:
+          return environments;
       }
-      this.setAccessPoints(
-        dataProduct?.dataProduct.accessPoints.map(
-          (accessPoint) => accessPoint.name,
-        ) ?? [],
-      );
+    };
+
+    if (this.dataProductDetails.length === 1) {
+      const environmentType =
+        this.dataProductDetails.at(0)?.lakehouseEnvironment?.type;
+      if (environmentType) {
+        this.setEnvironments(
+          filterEnvironments(environmentType, this.allEnvironments),
+        );
+      }
+    } else if (this.dataProductDetails.length > 1) {
+      const allEnvironments = new Set<string>();
+      this.dataProductDetails.forEach((dataProduct) => {
+        const environmentType = dataProduct.lakehouseEnvironment?.type;
+        if (environmentType) {
+          filterEnvironments(environmentType, this.allEnvironments).forEach(
+            (env) => allEnvironments.add(env),
+          );
+        }
+      });
+      this.setEnvironments(Array.from(allEnvironments));
     }
   }
 
+  fetchAccessPoints() {
+    this.resetAccessPoint();
+    const selectedEnv = guaranteeNonNullable(this.selectedEnvironment);
+    const dataProduct = selectedEnv.includes(
+      LakehouseEnvironmentType.DEVELOPMENT,
+    )
+      ? this.dataProductDetails.find(
+          (dp) =>
+            dp.lakehouseEnvironment?.type ===
+            V1_EntitlementsLakehouseEnvironmentType.DEVELOPMENT,
+        )
+      : selectedEnv.includes(LakehouseEnvironmentType.PRODUCTION_PARALLEL)
+        ? this.dataProductDetails.find(
+            (dp) =>
+              dp.lakehouseEnvironment?.type ===
+              V1_EntitlementsLakehouseEnvironmentType.PRODUCTION_PARALLEL,
+          )
+        : this.dataProductDetails.find(
+            (dp) =>
+              dp.lakehouseEnvironment?.type ===
+              V1_EntitlementsLakehouseEnvironmentType.PRODUCTION,
+          );
+    if (dataProduct?.origin instanceof V1_SdlcDeploymentDataProductOrigin) {
+      const versionedData = new VersionedProjectData();
+      versionedData.groupId = dataProduct.origin.group;
+      versionedData.artifactId = dataProduct.origin.artifact;
+      versionedData.versionId = dataProduct.origin.version;
+      this.dpCoordinates = versionedData;
+      this.origin = V1_DataProductOriginType.SDLC_DEPLOYMENT;
+    } else if (
+      dataProduct?.origin instanceof V1_AdHocDeploymentDataProductOrigin
+    ) {
+      this.dpCoordinates = undefined;
+      this.origin = V1_DataProductOriginType.AD_HOC_DEPLOYMENT;
+      this.fullGraphGrammar = dataProduct.origin.definition;
+    }
+    this.setAccessPoints(
+      dataProduct?.dataProduct.accessPoints.map(
+        (accessPoint) => accessPoint.name,
+      ) ?? [],
+    );
+  }
+
   *fetchEnvironment(access_token: string | undefined): GeneratorFn<void> {
     this.ingestEnvLoadingState.inProgress();
     const ingestServerConfigs =
       (yield this._platformServerClient.getIngestEnvironmentSummaries(
         access_token,
       )) as IngestDeploymentServerConfig[];
-    this.setEnvironments(
+    this.setAllEnvironments(
       ingestServerConfigs
         .map((config) => {
           const baseUrl = new URL(config.ingestServerUrl).hostname;
@@ -213,6 +293,13 @@ export class LakehouseConsumerDataCubeSourceBuilderState extends LegendDataCubeS
     this.dpCoordinates = undefined;
   }
 
+  resetAccessPoint() {
+    this.setWarehouse(undefined);
+    this.setAccessPoints([]);
+    this.setSelectedAccessPoint(undefined);
+    this.dpCoordinates = undefined;
+  }
+
   override get label(): LegendDataCubeSourceBuilderType {
     return LegendDataCubeSourceBuilderType.LAKEHOUSE_CONSUMER;
   }
@@ -222,7 +309,6 @@ export class LakehouseConsumerDataCubeSourceBuilderState extends LegendDataCubeS
       Boolean(this.warehouse) &&
       Boolean(this.selectedAccessPoint) &&
       Boolean(this.selectedDataProduct) &&
-      Boolean(this.dpCoordinates) &&
       Boolean(this.selectedEnvironment)
     );
   }
@@ -239,7 +325,14 @@ export class LakehouseConsumerDataCubeSourceBuilderState extends LegendDataCubeS
 
     const rawSource = new RawLakehouseConsumerDataCubeSource();
     rawSource.environment = guaranteeNonNullable(this.selectedEnvironment);
-    rawSource.dpCoordinates = guaranteeNonNullable(this.dpCoordinates);
+    if (this.origin === V1_DataProductOriginType.SDLC_DEPLOYMENT) {
+      const lakehouseOrigin = new RawLakehouseSdlcOrigin();
+      lakehouseOrigin.dpCoordinates = guaranteeNonNullable(this.dpCoordinates);
+      rawSource.origin = lakehouseOrigin;
+    } else {
+      this._engine.registerAdhocDataProductGraphGrammar(this.fullGraphGrammar);
+      rawSource.origin = new RawLakehouseAdhocOrigin();
+    }
     rawSource.paths = this.paths;
     rawSource.warehouse = guaranteeNonNullable(this.warehouse);
 

package/src/stores/builder/source/LakehouseConsumerDataCubeSourceLoaderState.ts

@@ -0,0 +1,169 @@
+/**
+ * Copyright (c) 2025-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 {
+  guaranteeNonNullable,
+  guaranteeType,
+  type PlainObject,
+} from '@finos/legend-shared';
+import type { LegendDataCubeApplicationStore } from '../../LegendDataCubeBaseStore.js';
+import type { LegendDataCubeDataCubeEngine } from '../../LegendDataCubeDataCubeEngine.js';
+import { LegendDataCubeSourceLoaderState } from './LegendDataCubeSourceLoaderState.js';
+import type { DataCubeAlertService } from '@finos/legend-data-cube';
+import {
+  V1_AdHocDeploymentDataProductOrigin,
+  V1_entitlementsDataProductDetailsResponseToDataProductDetails,
+  V1_EntitlementsLakehouseEnvironmentType,
+  type PersistentDataCube,
+} from '@finos/legend-graph';
+import type { LakehouseContractServerClient } from '@finos/legend-server-lakehouse';
+import { action, makeObservable, observable } from 'mobx';
+import { LegendDataCubeSourceBuilderType } from './LegendDataCubeSourceBuilderState.js';
+import {
+  LakehouseEnvironmentType,
+  RawLakehouseConsumerDataCubeSource,
+  RawLakehouseSdlcOrigin,
+} from '../../model/LakehouseConsumerDataCubeSource.js';
+
+export class LakehouseConsumerDataCubeSourceLoaderState extends LegendDataCubeSourceLoaderState {
+  fullGraphGrammar: string | undefined;
+  dataProductId: string | undefined;
+  dpLoaded: boolean;
+  environment: string | undefined;
+
+  constructor(
+    application: LegendDataCubeApplicationStore,
+    engine: LegendDataCubeDataCubeEngine,
+    alertService: DataCubeAlertService,
+    sourceData: PlainObject,
+    persistentDataCube: PersistentDataCube,
+    onSuccess: () => Promise<void>,
+    onError: (error: unknown) => Promise<void>,
+  ) {
+    super(
+      application,
+      engine,
+      alertService,
+      sourceData,
+      persistentDataCube,
+      onSuccess,
+      onError,
+    );
+    this.dpLoaded = false;
+
+    makeObservable(this, {
+      dpLoaded: observable,
+      setDpLoaded: action,
+
+      dataProductId: observable,
+      setDataProductId: action,
+    });
+  }
+
+  setDpLoaded(dpLoaded: boolean) {
+    this.dpLoaded = dpLoaded;
+  }
+
+  setDataProductId(id: string | undefined) {
+    this.dataProductId = id;
+  }
+
+  override get isValid(): boolean {
+    return this.dpLoaded;
+  }
+
+  override get label() {
+    return LegendDataCubeSourceBuilderType.LAKEHOUSE_CONSUMER;
+  }
+
+  reset() {
+    const rawSource = RawLakehouseConsumerDataCubeSource.serialization.fromJson(
+      this.sourceData,
+    );
+    if (
+      !rawSource.origin ||
+      rawSource.origin instanceof RawLakehouseSdlcOrigin
+    ) {
+      this.setDpLoaded(true);
+    } else {
+      this.setDpLoaded(false);
+    }
+    this.setDataProductId(rawSource.paths[0]);
+    this.environment = rawSource.environment;
+    this.fullGraphGrammar = undefined;
+  }
+
+  async loadAdhocDataProduct(
+    access_token: string | undefined,
+    lakehouseContractServerClient: LakehouseContractServerClient,
+  ) {
+    const dataProducts =
+      V1_entitlementsDataProductDetailsResponseToDataProductDetails(
+        await lakehouseContractServerClient.getDataProduct(
+          this.dataProductId?.split('::').pop() ?? '',
+          access_token,
+        ),
+      );
+
+    const selectedEnv = guaranteeNonNullable(this.environment);
+
+    const dataProduct = selectedEnv.includes(
+      LakehouseEnvironmentType.DEVELOPMENT,
+    )
+      ? dataProducts.find(
+          (dp) =>
+            dp.lakehouseEnvironment?.type ===
+            V1_EntitlementsLakehouseEnvironmentType.DEVELOPMENT,
+        )
+      : selectedEnv.includes(LakehouseEnvironmentType.PRODUCTION_PARALLEL)
+        ? dataProducts.find(
+            (dp) =>
+              dp.lakehouseEnvironment?.type ===
+              V1_EntitlementsLakehouseEnvironmentType.PRODUCTION_PARALLEL,
+          )
+        : dataProducts.find(
+            (dp) =>
+              dp.lakehouseEnvironment?.type ===
+              V1_EntitlementsLakehouseEnvironmentType.PRODUCTION,
+          );
+
+    if (
+      dataProduct?.origin &&
+      dataProduct.origin instanceof V1_AdHocDeploymentDataProductOrigin
+    ) {
+      this.fullGraphGrammar = guaranteeType(
+        dataProduct.origin,
+        V1_AdHocDeploymentDataProductOrigin,
+      ).definition;
+      this.setDpLoaded(true);
+    }
+  }
+
+  override async load(source: PlainObject | undefined) {
+    const deserializedSource =
+      RawLakehouseConsumerDataCubeSource.serialization.fromJson(
+        guaranteeNonNullable(source),
+      );
+
+    if (this.fullGraphGrammar) {
+      this._engine.registerAdhocDataProductGraphGrammar(this.fullGraphGrammar);
+    }
+
+    return RawLakehouseConsumerDataCubeSource.serialization.toJson(
+      deserializedSource,
+    );
+  }
+}

package/src/stores/builder/source/LakehouseProducerDataCubeSourceLoaderState.ts

@@ -15,7 +15,6 @@
  */
 
 import {
-  ActionState,
   guaranteeNonNullable,
   guaranteeType,
   type PlainObject,
@@ -38,8 +37,6 @@ import type { UserManagerSettings } from 'oidc-client-ts';
 import { SecondaryOAuthClient } from '../../model/SecondaryOauthClient.js';
 
 export class LakehouseProducerDataCubeSourceLoaderState extends LegendDataCubeSourceLoaderState {
-  readonly processState = ActionState.create();
-
   ingestDefinition: PlainObject | undefined;
   ingestDefinitionUrn: string;
   ingestServerUrl: string;

package/src/stores/model/LakehouseConsumerDataCubeSource.ts

@@ -15,42 +15,131 @@
  */
 
 import { DataCubeSource } from '@finos/legend-data-cube';
-import type { V1_PureModelContextData } from '@finos/legend-graph';
+import {
+  V1_DataProductOriginType,
+  type V1_PureModelContextData,
+} from '@finos/legend-graph';
 import { VersionedProjectData } from '@finos/legend-server-depot';
 import {
+  optionalCustom,
   SerializationFactory,
+  UnsupportedOperationError,
   usingConstantValueSchema,
   usingModelSchema,
   type PlainObject,
 } from '@finos/legend-shared';
-import { createModelSchema, list, primitive } from 'serializr';
+import {
+  createModelSchema,
+  deserialize,
+  list,
+  primitive,
+  serialize,
+} from 'serializr';
 
 export const LAKEHOUSE_CONSUMER_DATA_CUBE_SOURCE_TYPE = 'lakehouseConsumer';
 
 export class LakehouseConsumerDataCubeSource extends DataCubeSource {
   model!: PlainObject<V1_PureModelContextData>;
-  dpCoordinates!: VersionedProjectData;
+  dpCoordinates?: VersionedProjectData;
   runtime!: string;
   warehouse!: string;
   environment!: string;
   paths!: string[];
 }
 
-export class RawLakehouseConsumerDataCubeSource {
+export enum LakehouseEnvironmentType {
+  DEVELOPMENT = 'dev',
+  PRODUCTION_PARALLEL = 'pp',
+}
+
+export abstract class RawLakehouseOrigin {}
+
+export class RawLakehouseAdhocOrigin extends RawLakehouseOrigin {
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(RawLakehouseAdhocOrigin, {
+      _type: usingConstantValueSchema(
+        V1_DataProductOriginType.AD_HOC_DEPLOYMENT,
+      ),
+    }),
+  );
+}
+
+export class RawLakehouseSdlcOrigin extends RawLakehouseOrigin {
   dpCoordinates!: VersionedProjectData;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(RawLakehouseSdlcOrigin, {
+      _type: usingConstantValueSchema(V1_DataProductOriginType.SDLC_DEPLOYMENT),
+      dpCoordinates: usingModelSchema(
+        VersionedProjectData.serialization.schema,
+      ),
+    }),
+  );
+}
+
+export class RawLakehouseConsumerDataCubeSource {
   warehouse!: string;
   environment!: string;
   paths!: string[];
+  origin?: RawLakehouseOrigin;
 
   static readonly serialization = new SerializationFactory(
     createModelSchema(RawLakehouseConsumerDataCubeSource, {
       _type: usingConstantValueSchema(LAKEHOUSE_CONSUMER_DATA_CUBE_SOURCE_TYPE),
-      dpCoordinates: usingModelSchema(
-        VersionedProjectData.serialization.schema,
-      ),
       warehouse: primitive(),
       environment: primitive(),
       paths: list(primitive()),
+      origin: optionalCustom(
+        (value) => {
+          if (value instanceof RawLakehouseAdhocOrigin) {
+            return serialize(
+              RawLakehouseAdhocOrigin.serialization.schema,
+              value,
+            );
+          } else if (value instanceof RawLakehouseSdlcOrigin) {
+            return serialize(
+              RawLakehouseSdlcOrigin.serialization.schema,
+              value,
+            );
+          } else {
+            throw new Error(
+              `Can't serialize RawLakehouseOrigin: no compatible serialization schema available from the provided value`,
+            );
+          }
+        },
+        (jsonValue) => {
+          switch (jsonValue._type) {
+            case V1_DataProductOriginType.AD_HOC_DEPLOYMENT:
+              return deserialize(
+                RawLakehouseAdhocOrigin.serialization.schema,
+                jsonValue,
+              );
+            case V1_DataProductOriginType.SDLC_DEPLOYMENT:
+              return deserialize(
+                RawLakehouseSdlcOrigin.serialization.schema,
+                jsonValue,
+              );
+            default:
+              throw new UnsupportedOperationError(
+                `Can't deserialize RawLakehouseOrigin: no compatible deserialization schema for type '${jsonValue._type}'`,
+              );
+          }
+        },
+        {
+          beforeDeserialize: (callback, jsonValue, jsonParentValue) => {
+            /** backward compatibility for dpCoordinates */
+            if (!jsonValue && jsonParentValue.dpCoordinates) {
+              const origin = {
+                _type: V1_DataProductOriginType.SDLC_DEPLOYMENT,
+                dpCoordinates: jsonParentValue.dpCoordinates,
+              } as PlainObject;
+              callback(null, origin);
+            } else {
+              callback(null, jsonValue);
+            }
+          },
+        },
+      ),
     }),
   );
 }

package/tsconfig.json

@@ -68,6 +68,7 @@
     "./src/stores/LegendDataCubeDuckDBEngine.ts",
     "./src/stores/builder/source/FreeformTDSExpressionDataCubeSourceBuilderState.ts",
     "./src/stores/builder/source/LakehouseConsumerDataCubeSourceBuilderState.ts",
+    "./src/stores/builder/source/LakehouseConsumerDataCubeSourceLoaderState.ts",
     "./src/stores/builder/source/LakehouseProducerDataCubeSourceBuilderState.ts",
     "./src/stores/builder/source/LakehouseProducerDataCubeSourceLoaderState.ts",
     "./src/stores/builder/source/LegendDataCubeSourceBuilderState.ts",
@@ -96,6 +97,7 @@
     "./src/components/builder/LegendDataCubeSourceViewer.tsx",
     "./src/components/builder/source/FreeformTDSExpressionDataCubeSourceBuilder.tsx",
     "./src/components/builder/source/LakehouseConsumerDataCubeSourceBuilder.tsx",
+    "./src/components/builder/source/LakehouseConsumerDataCubeSourceLoader.tsx",
     "./src/components/builder/source/LakehouseProducerDataCubeSourceBuilder.tsx",
     "./src/components/builder/source/LakehouseProducerDataCubeSourceLoader.tsx",
     "./src/components/builder/source/LegendDataCubeSourceLoader.tsx",