@finos/legend-application-studio 28.18.113 → 28.18.115

package/src/stores/editor/editor-state/element-editor-state/dataProduct/DataProductEditorState.ts

@@ -0,0 +1,260 @@
+/**
+ * Copyright (c) 2020-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 {
+  DataProduct,
+  LakehouseAccessPoint,
+  type PackageableElement,
+  type AccessPoint,
+  stub_RawLambda,
+  LakehouseTargetEnv,
+  LAMBDA_PIPE,
+  type RawLambda,
+  ParserError,
+  GRAPH_MANAGER_EVENT,
+  isStubbed_RawLambda,
+} from '@finos/legend-graph';
+import type { EditorStore } from '../../../EditorStore.js';
+import { ElementEditorState } from '../ElementEditorState.js';
+import { action, computed, flow, makeObservable, observable } from 'mobx';
+import {
+  guaranteeType,
+  addUniqueEntry,
+  type GeneratorFn,
+  assertErrorThrown,
+  LogEvent,
+  deleteEntry,
+  filterByType,
+} from '@finos/legend-shared';
+import {
+  dataProduct_addAccessPoint,
+  dataProduct_deleteAccessPoint,
+} from '../../../../graph-modifier/DSL_DataProduct_GraphModifierHelper.js';
+import { LambdaEditorState } from '@finos/legend-query-builder';
+
+export class AccessPointState {
+  readonly state: DataProductEditorState;
+  accessPoint: AccessPoint;
+
+  constructor(val: AccessPoint, editorState: DataProductEditorState) {
+    this.accessPoint = val;
+    this.state = editorState;
+  }
+}
+
+export class AccessPointLambdaEditorState extends LambdaEditorState {
+  readonly editorStore: EditorStore;
+  readonly val: LakehouseAccessPointState;
+
+  constructor(val: LakehouseAccessPointState) {
+    super('', LAMBDA_PIPE);
+    this.val = val;
+    this.editorStore = val.state.editorStore;
+  }
+
+  override get lambdaId(): string {
+    return this.val.accessPoint.id;
+  }
+
+  *convertLambdaGrammarStringToObject(): GeneratorFn<void> {
+    const emptyLambda = stub_RawLambda();
+    if (this.lambdaString) {
+      try {
+        const lambda =
+          (yield this.editorStore.graphManagerState.graphManager.pureCodeToLambda(
+            this.fullLambdaString,
+            this.lambdaId,
+          )) as RawLambda;
+        this.setParserError(undefined);
+        this.val.accessPoint.func = lambda;
+      } catch (error) {
+        assertErrorThrown(error);
+        if (error instanceof ParserError) {
+          this.setParserError(error);
+        }
+        this.editorStore.applicationStore.logService.error(
+          LogEvent.create(GRAPH_MANAGER_EVENT.PARSING_FAILURE),
+          error,
+        );
+      }
+    } else {
+      this.clearErrors();
+      this.val.accessPoint.func = emptyLambda;
+    }
+  }
+
+  *convertLambdaObjectToGrammarString(options?: {
+    pretty?: boolean | undefined;
+    preserveCompilationError?: boolean | undefined;
+  }): GeneratorFn<void> {
+    if (
+      !isStubbed_RawLambda(this.val.accessPoint.func) &&
+      !this.val.state.isConvertingTransformLambdaObjects
+    ) {
+      try {
+        const lambdas = new Map<string, RawLambda>();
+        lambdas.set(this.lambdaId, this.val.accessPoint.func);
+        const isolatedLambdas =
+          (yield this.editorStore.graphManagerState.graphManager.lambdasToPureCode(
+            lambdas,
+            options?.pretty,
+          )) as Map<string, string>;
+        const grammarText = isolatedLambdas.get(this.lambdaId);
+        this.setLambdaString(
+          grammarText !== undefined
+            ? this.extractLambdaString(grammarText)
+            : '',
+        );
+        this.clearErrors({
+          preserveCompilationError: options?.preserveCompilationError,
+        });
+      } catch (error) {
+        assertErrorThrown(error);
+        this.editorStore.applicationStore.logService.error(
+          LogEvent.create(GRAPH_MANAGER_EVENT.PARSING_FAILURE),
+          error,
+        );
+      }
+    } else {
+      this.clearErrors();
+      this.setLambdaString('');
+    }
+  }
+}
+export class LakehouseAccessPointState extends AccessPointState {
+  declare accessPoint: LakehouseAccessPoint;
+  lambdaState: AccessPointLambdaEditorState;
+
+  constructor(val: LakehouseAccessPoint, editorState: DataProductEditorState) {
+    super(val, editorState);
+    makeObservable(this, {
+      lambdaState: observable,
+    });
+    this.accessPoint = val;
+    this.lambdaState = new AccessPointLambdaEditorState(this);
+  }
+}
+
+export class DataProductEditorState extends ElementEditorState {
+  accessPointModal = false;
+  accessPointStates: AccessPointState[] = [];
+  isConvertingTransformLambdaObjects = false;
+
+  constructor(editorStore: EditorStore, element: PackageableElement) {
+    super(editorStore, element);
+
+    makeObservable(this, {
+      product: computed,
+      accessPointModal: observable,
+      accessPointStates: observable,
+      deleteAccessPoint: observable,
+      isConvertingTransformLambdaObjects: observable,
+      setAccessPointModal: action,
+      addAccessPoint: action,
+      convertAccessPointsFuncObjects: flow,
+    });
+    this.accessPointStates = this.product.accessPoints.map((e) =>
+      this.buildAccessPointState(e),
+    );
+  }
+
+  *convertAccessPointsFuncObjects(): GeneratorFn<void> {
+    const lambdas = new Map<string, RawLambda>();
+    const index = new Map<string, LakehouseAccessPointState>();
+    const states = this.accessPointStates.filter(
+      filterByType(LakehouseAccessPointState),
+    );
+    states.forEach((pm) => {
+      if (!isStubbed_RawLambda(pm.accessPoint.func)) {
+        lambdas.set(pm.lambdaState.lambdaId, pm.accessPoint.func);
+        index.set(pm.lambdaState.lambdaId, pm);
+      }
+    });
+    if (lambdas.size) {
+      this.isConvertingTransformLambdaObjects = true;
+      try {
+        const isolatedLambdas =
+          (yield this.editorStore.graphManagerState.graphManager.lambdasToPureCode(
+            lambdas,
+          )) as Map<string, string>;
+        isolatedLambdas.forEach((grammarText, key) => {
+          const purePropertyMapping = index.get(key);
+          purePropertyMapping?.lambdaState.setLambdaString(
+            purePropertyMapping.lambdaState.extractLambdaString(grammarText),
+          );
+        });
+      } catch (error) {
+        assertErrorThrown(error);
+        this.editorStore.applicationStore.logService.error(
+          LogEvent.create(GRAPH_MANAGER_EVENT.PARSING_FAILURE),
+          error,
+        );
+      } finally {
+        this.isConvertingTransformLambdaObjects = false;
+      }
+    }
+  }
+
+  buildAccessPointState(val: AccessPoint): AccessPointState {
+    if (val instanceof LakehouseAccessPoint) {
+      return new LakehouseAccessPointState(val, this);
+    }
+    return new AccessPointState(val, this);
+  }
+
+  setAccessPointModal(val: boolean): void {
+    this.accessPointModal = val;
+  }
+
+  deleteAccessPoint(val: AccessPointState): void {
+    const ap = val.accessPoint;
+    dataProduct_deleteAccessPoint(this.product, ap);
+    deleteEntry(this.accessPointStates, val);
+  }
+
+  addAccessPoint(id: string): void {
+    const accesspoint = new LakehouseAccessPoint(
+      id,
+      LakehouseTargetEnv.Snowflake,
+      stub_RawLambda(),
+    );
+    dataProduct_addAccessPoint(this.product, accesspoint);
+    addUniqueEntry(
+      this.accessPointStates,
+      this.buildAccessPointState(accesspoint),
+    );
+  }
+
+  get product(): DataProduct {
+    return guaranteeType(
+      this.element,
+      DataProduct,
+      'Element inside data product editor state must be a data product',
+    );
+  }
+
+  get accessPoints(): AccessPoint[] {
+    return this.product.accessPoints;
+  }
+
+  override reprocess(
+    newElement: PackageableElement,
+    editorStore: EditorStore,
+  ): DataProductEditorState {
+    const editorState = new DataProductEditorState(editorStore, newElement);
+    return editorState;
+  }
+}

package/src/stores/editor/utils/ModelClassifierUtils.ts

@@ -71,6 +71,8 @@ export enum PACKAGEABLE_ELEMENT_TYPE {
   DATA = 'DATA',
   SNOWFLAKE_APP = 'SNOWFLAKE_APP',
   HOSTED_SERVICE = 'HOSTED_SERVICE',
+  // New Strategical Data Product
+  _DATA_PRODUCT = 'BETA_DATA_PRODUCT',
 
   TEMPORARY__LOCAL_CONNECTION = 'LOCAL_CONNECTION',
   INTERNAL__UnknownElement = 'UNKNOWN',

package/src/stores/graph-modifier/DSL_DataProduct_GraphModifierHelper.ts

@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2020-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 AccessPoint,
+  type DataProduct,
+  observe_AccessPoint,
+} from '@finos/legend-graph';
+import { addUniqueEntry, deleteEntry } from '@finos/legend-shared';
+
+import { action } from 'mobx';
+
+export const dataProduct_deleteAccessPoint = action(
+  (product: DataProduct, accessPoint: AccessPoint) => {
+    deleteEntry(product.accessPoints, accessPoint);
+  },
+);
+
+export const dataProduct_addAccessPoint = action(
+  (product: DataProduct, accessPoint: AccessPoint) => {
+    addUniqueEntry(product.accessPoints, observe_AccessPoint(accessPoint));
+  },
+);

package/tsconfig.json

@@ -125,6 +125,7 @@
     "./src/stores/editor/editor-state/element-editor-state/connection/PostProcessorEditorState.ts",
     "./src/stores/editor/editor-state/element-editor-state/data/DataEditorState.ts",
     "./src/stores/editor/editor-state/element-editor-state/data/EmbeddedDataState.ts",
+    "./src/stores/editor/editor-state/element-editor-state/dataProduct/DataProductEditorState.ts",
     "./src/stores/editor/editor-state/element-editor-state/database/QueryDatabaseState.ts",
     "./src/stores/editor/editor-state/element-editor-state/external-format/DSL_ExternalFormat_BindingEditorState.ts",
     "./src/stores/editor/editor-state/element-editor-state/external-format/DSL_ExternalFormat_SchemaSetEditorState.ts",
@@ -187,6 +188,7 @@
     "./src/stores/extensions/DSL_Mapping_LegendStudioApplicationPlugin_Extension.ts",
     "./src/stores/extensions/DSL_Service_LegendStudioApplicationPlugin_Extension.ts",
     "./src/stores/extensions/STO_Relational_LegendStudioApplicationPlugin_Extension.ts",
+    "./src/stores/graph-modifier/DSL_DataProduct_GraphModifierHelper.ts",
     "./src/stores/graph-modifier/DSL_Data_GraphModifierHelper.ts",
     "./src/stores/graph-modifier/DSL_ExternalFormat_GraphModifierHelper.ts",
     "./src/stores/graph-modifier/DSL_FunctionActivator_GraphModifierHelper.ts",
@@ -242,6 +244,7 @@
     "./src/components/editor/editor-group/data-editor/DataElementEditor.tsx",
     "./src/components/editor/editor-group/data-editor/EmbeddedDataEditor.tsx",
     "./src/components/editor/editor-group/data-editor/RelationalCSVDataEditor.tsx",
+    "./src/components/editor/editor-group/dataProduct/DataPoductEditor.tsx",
     "./src/components/editor/editor-group/database/IsolatedQueryDatabase.tsx",
     "./src/components/editor/editor-group/diff-editor/EntityChangeConflictEditor.tsx",
     "./src/components/editor/editor-group/diff-editor/EntityDiffView.tsx",