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

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,135 @@
  */
 
 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,
+  optional,
+  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[];
+  deploymentId?: number | undefined;
 }
 
-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[];
+  deploymentId?: number | undefined;
+  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()),
+      deploymentId: optional(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/src/stores/model/LakehouseProducerDataCubeSource.ts

@@ -29,6 +29,8 @@ export const LAKEHOUSE_PRODUCER_DATA_CUBE_SOURCE_TYPE = 'lakehouseProducer';
 export class LakehouseProducerDataCubeSource extends DataCubeSource {
   model!: PlainObject<V1_PureModelContextData>;
   runtime!: string;
+  paths!: string[];
+  warehouse!: string;
 }
 
 export class LakehouseProducerIcebergCachedDataCubeSource extends DataCubeSource {
@@ -37,6 +39,7 @@ export class LakehouseProducerIcebergCachedDataCubeSource extends DataCubeSource
   db!: string;
   schema!: string;
   table!: string;
+  paths!: string[];
 }
 
 export class IcebergConfig {

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",