@finos/legend-extension-dsl-data-space 9.1.7 → 9.2.1

package/src/graphManager/protocol/pure/v1/engine/analytics/V1_DataSpaceAnalysis.ts

@@ -22,6 +22,8 @@ import {
   UnsupportedOperationError,
   customListWithSchema,
   usingConstantValueSchema,
+  isString,
+  isNonNullable,
 } from '@finos/legend-shared';
 import {
   createModelSchema,
@@ -317,15 +319,13 @@ export class V1_DataSpaceAnalysisResult {
   executionContexts: V1_DataSpaceExecutionContextAnalysisResult[] = [];
   defaultExecutionContext!: string;
 
-  featuredDiagrams: string[] = [];
-
   elements: string[] = [];
   elementDocs: V1_DataSpaceModelDocumentationEntry[] = [];
 
   executables: V1_DataSpaceExecutableAnalysisResult[] = [];
   diagrams: V1_DataSpaceDiagramAnalysisResult[] = [];
 
-  static readonly serialization = new SerializationFactory(
+  private static readonly serialization = new SerializationFactory(
     createModelSchema(V1_DataSpaceAnalysisResult, {
       name: primitive(),
       package: primitive(),
@@ -363,4 +363,35 @@ export class V1_DataSpaceAnalysisResult {
       ),
     }),
   );
+
+  static deserialize(
+    json: PlainObject<V1_DataSpaceAnalysisResult>,
+  ): V1_DataSpaceAnalysisResult {
+    const result = deserialize(
+      V1_DataSpaceAnalysisResult.serialization.schema,
+      json,
+    );
+    /**
+     * Featured diagrams will be transformed to diagrams, so here we nicely
+     * auto-transform it for backward compatibility
+     *
+     * @backwardCompatibility
+     */
+    if (json.featuredDiagrams && Array.isArray(json.featuredDiagrams)) {
+      const diagramResults = json.featuredDiagrams
+        .map((featuredDiagram) => {
+          if (isString(featuredDiagram)) {
+            const diagramAnalysisResult =
+              new V1_DataSpaceDiagramAnalysisResult();
+            diagramAnalysisResult.title = '';
+            diagramAnalysisResult.diagram = featuredDiagram;
+            return diagramAnalysisResult;
+          }
+          return undefined;
+        })
+        .filter(isNonNullable);
+      result.diagrams = result.diagrams.concat(diagramResults);
+    }
+    return result;
+  }
 }

package/src/graphManager/protocol/pure/v1/model/packageableElements/dataSpace/V1_DSL_DataSpace_DataSpace.ts

@@ -24,48 +24,6 @@ import {
   type V1_TaggedValue,
 } from '@finos/legend-graph';
 
-export abstract class V1_DataSpaceSupportInfo implements Hashable {
-  documentationUrl?: string | undefined;
-
-  abstract get hashCode(): string;
-}
-
-export class V1_DataSpaceSupportEmail
-  extends V1_DataSpaceSupportInfo
-  implements Hashable
-{
-  address!: string;
-
-  get hashCode(): string {
-    return hashArray([
-      DATA_SPACE_HASH_STRUCTURE.DATA_SPACE_SUPPORT_EMAIL,
-      this.documentationUrl ?? '',
-      this.address,
-    ]);
-  }
-}
-
-export class V1_DataSpaceSupportCombinedInfo
-  extends V1_DataSpaceSupportInfo
-  implements Hashable
-{
-  emails?: string[] | undefined;
-  website?: string | undefined;
-  faqUrl?: string | undefined;
-  supportUrl?: string | undefined;
-
-  get hashCode(): string {
-    return hashArray([
-      DATA_SPACE_HASH_STRUCTURE.DATA_SPACE_SUPPORT_COMBINED_INFO,
-      this.documentationUrl ?? '',
-      hashArray(this.emails ?? []),
-      this.website ?? '',
-      this.faqUrl ?? '',
-      this.supportUrl ?? '',
-    ]);
-  }
-}
-
 export class V1_DataSpaceExecutionContext implements Hashable {
   name!: string;
   title?: string | undefined;
@@ -85,6 +43,19 @@ export class V1_DataSpaceExecutionContext implements Hashable {
   }
 }
 
+export class V1_DataSpaceElementPointer implements Hashable {
+  path!: string;
+  exclude?: boolean | undefined;
+
+  get hashCode(): string {
+    return hashArray([
+      DATA_SPACE_HASH_STRUCTURE.DATA_SPACE_ELEMENT_POINTER,
+      this.path,
+      this.exclude ?? '',
+    ]);
+  }
+}
+
 export class V1_DataSpaceExecutable implements Hashable {
   title!: string;
   description?: string | undefined;
@@ -115,6 +86,48 @@ export class V1_DataSpaceDiagram implements Hashable {
   }
 }
 
+export abstract class V1_DataSpaceSupportInfo implements Hashable {
+  documentationUrl?: string | undefined;
+
+  abstract get hashCode(): string;
+}
+
+export class V1_DataSpaceSupportEmail
+  extends V1_DataSpaceSupportInfo
+  implements Hashable
+{
+  address!: string;
+
+  get hashCode(): string {
+    return hashArray([
+      DATA_SPACE_HASH_STRUCTURE.DATA_SPACE_SUPPORT_EMAIL,
+      this.documentationUrl ?? '',
+      this.address,
+    ]);
+  }
+}
+
+export class V1_DataSpaceSupportCombinedInfo
+  extends V1_DataSpaceSupportInfo
+  implements Hashable
+{
+  emails?: string[] | undefined;
+  website?: string | undefined;
+  faqUrl?: string | undefined;
+  supportUrl?: string | undefined;
+
+  get hashCode(): string {
+    return hashArray([
+      DATA_SPACE_HASH_STRUCTURE.DATA_SPACE_SUPPORT_COMBINED_INFO,
+      this.documentationUrl ?? '',
+      hashArray(this.emails ?? []),
+      this.website ?? '',
+      this.faqUrl ?? '',
+      this.supportUrl ?? '',
+    ]);
+  }
+}
+
 export class V1_DataSpace extends V1_PackageableElement implements Hashable {
   stereotypes: V1_StereotypePtr[] = [];
   taggedValues: V1_TaggedValue[] = [];
@@ -122,8 +135,7 @@ export class V1_DataSpace extends V1_PackageableElement implements Hashable {
   description?: string | undefined;
   executionContexts!: V1_DataSpaceExecutionContext[];
   defaultExecutionContext!: string;
-  featuredDiagrams?: V1_PackageableElementPointer[] | undefined;
-  elements?: V1_PackageableElementPointer[] | undefined;
+  elements?: V1_DataSpaceElementPointer[] | undefined;
   executables?: V1_DataSpaceExecutable[] | undefined;
   diagrams?: V1_DataSpaceDiagram[] | undefined;
   supportInfo?: V1_DataSpaceSupportInfo | undefined;
@@ -137,8 +149,7 @@ export class V1_DataSpace extends V1_PackageableElement implements Hashable {
       this.description ?? '',
       hashArray(this.executionContexts),
       this.defaultExecutionContext,
-      hashArray((this.featuredDiagrams ?? []).map((pointer) => pointer.path)),
-      hashArray((this.elements ?? []).map((pointer) => pointer.path)),
+      hashArray(this.elements ?? []),
       hashArray(this.executables ?? []),
       hashArray(this.diagrams ?? []),
       this.supportInfo ?? '',

package/src/graphManager/protocol/pure/v1/transformation/pureProtocol/V1_DSL_DataSpace_ProtocolHelper.ts

@@ -28,7 +28,8 @@ import {
 import {
   V1_stereotypePtrSchema,
   V1_taggedValueSchema,
-  V1_packageableElementPointerDeserializerSchema,
+  V1_packageableElementPointerModelSchema,
+  V1_PackageableElementPointer,
 } from '@finos/legend-graph';
 import {
   type PlainObject,
@@ -37,6 +38,8 @@ import {
   usingModelSchema,
   optionalCustomListWithSchema,
   customListWithSchema,
+  isString,
+  isNonNullable,
 } from '@finos/legend-shared';
 import {
   type V1_DataSpaceSupportInfo,
@@ -46,6 +49,7 @@ import {
   V1_DataSpaceSupportCombinedInfo,
   V1_DataSpaceExecutable,
   V1_DataSpaceDiagram,
+  V1_DataSpaceElementPointer,
 } from '../../model/packageableElements/dataSpace/V1_DSL_DataSpace_DataSpace.js';
 
 export const V1_DATA_SPACE_ELEMENT_PROTOCOL_TYPE = 'dataSpace';
@@ -55,11 +59,9 @@ const V1_DATA_SPACE_SUPPORT_COMBINED_INFO_TYPE = 'combined';
 const V1_dataSpaceExecutionContextModelSchema = createModelSchema(
   V1_DataSpaceExecutionContext,
   {
-    defaultRuntime: usingModelSchema(
-      V1_packageableElementPointerDeserializerSchema,
-    ),
+    defaultRuntime: usingModelSchema(V1_packageableElementPointerModelSchema),
     description: optional(primitive()),
-    mapping: usingModelSchema(V1_packageableElementPointerDeserializerSchema),
+    mapping: usingModelSchema(V1_packageableElementPointerModelSchema),
     name: primitive(),
     title: optional(primitive()),
   },
@@ -119,35 +121,39 @@ export const V1_deserializeSupportInfo = (
   }
 };
 
+const V1_dataSpaceElementPointerModelSchema = createModelSchema(
+  V1_DataSpaceElementPointer,
+  {
+    exclude: optional(primitive()),
+    path: primitive(),
+  },
+);
+
 const V1_dataSpaceExecutableModelSchema = createModelSchema(
   V1_DataSpaceExecutable,
   {
     description: optional(primitive()),
-    executable: usingModelSchema(
-      V1_packageableElementPointerDeserializerSchema,
-    ),
+    executable: usingModelSchema(V1_packageableElementPointerModelSchema),
     title: primitive(),
   },
 );
 
 const V1_dataSpaceDiagramModelSchema = createModelSchema(V1_DataSpaceDiagram, {
   description: optional(primitive()),
-  diagram: usingModelSchema(V1_packageableElementPointerDeserializerSchema),
+  diagram: usingModelSchema(V1_packageableElementPointerModelSchema),
   title: primitive(),
 });
 
-export const V1_dataSpaceModelSchema = createModelSchema(V1_DataSpace, {
+const V1_dataSpaceModelSchema = createModelSchema(V1_DataSpace, {
   _type: usingConstantValueSchema(V1_DATA_SPACE_ELEMENT_PROTOCOL_TYPE),
   defaultExecutionContext: primitive(),
   description: optional(primitive()),
   diagrams: list(object(V1_dataSpaceDiagramModelSchema)),
-  elements: optionalCustomListWithSchema(
-    V1_packageableElementPointerDeserializerSchema,
-  ),
+  elements: optionalCustomListWithSchema(V1_dataSpaceElementPointerModelSchema),
   executables: list(object(V1_dataSpaceExecutableModelSchema)),
   executionContexts: list(object(V1_dataSpaceExecutionContextModelSchema)),
   featuredDiagrams: optionalCustomListWithSchema(
-    V1_packageableElementPointerDeserializerSchema,
+    V1_packageableElementPointerModelSchema,
   ),
   name: primitive(),
   package: primitive(),
@@ -163,3 +169,42 @@ export const V1_dataSpaceModelSchema = createModelSchema(V1_DataSpace, {
   }),
   title: optional(primitive()),
 });
+
+export const V1_serializeDataSpace = (
+  protocol: V1_DataSpace,
+): PlainObject<V1_DataSpace> => serialize(V1_dataSpaceModelSchema, protocol);
+
+export const V1_deserializeDataSpace = (
+  json: PlainObject<V1_DataSpace>,
+): V1_DataSpace => {
+  const dataSpace = deserialize(V1_dataSpaceModelSchema, json);
+  /**
+   * Featured diagrams will be transformed to diagrams, so here we nicely
+   * auto-transform it for backward compatibility
+   *
+   * @backwardCompatibility
+   */
+  if (json.featuredDiagrams && Array.isArray(json.featuredDiagrams)) {
+    const diagrams = json.featuredDiagrams
+      .map((featuredDiagram) => {
+        if (isString(featuredDiagram.path)) {
+          const diagram = new V1_DataSpaceDiagram();
+          diagram.title = '';
+          diagram.diagram = new V1_PackageableElementPointer(
+            undefined,
+            featuredDiagram.path,
+          );
+          return diagram;
+        }
+        return undefined;
+      })
+      .filter(isNonNullable);
+    if (diagrams.length) {
+      dataSpace.diagrams =
+        dataSpace.diagrams !== undefined
+          ? dataSpace.diagrams.concat(diagrams)
+          : diagrams;
+    }
+  }
+  return dataSpace;
+};

package/src/stores/DataSpaceViewerDataAccessState.ts

@@ -0,0 +1,146 @@
+/**
+ * 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 GeneratorFn,
+  ActionState,
+  assertErrorThrown,
+  uuid,
+} from '@finos/legend-shared';
+import { action, flow, makeObservable, observable } from 'mobx';
+import type { DataSpaceViewerState } from './DataSpaceViewerState.js';
+import type {
+  DatasetSpecification,
+  DatasetEntitlementReport,
+} from '@finos/legend-graph';
+
+export class DataSpaceDatasetInfo {
+  readonly uuid = uuid();
+  readonly specification!: DatasetSpecification;
+
+  entitlementReport?: DatasetEntitlementReport | undefined;
+
+  constructor(specification: DatasetSpecification) {
+    makeObservable(this, {
+      entitlementReport: observable,
+      setEntitlementReport: action,
+    });
+
+    this.specification = specification;
+  }
+
+  setEntitlementReport(val: DatasetEntitlementReport | undefined): void {
+    this.entitlementReport = val;
+  }
+}
+
+export class DataSpaceViewerDataAccessState {
+  readonly dataSpaceViewerState: DataSpaceViewerState;
+
+  readonly fetchDatasetSpecificationsState = ActionState.create();
+  readonly fetchDatasetEntitlementReportsState = ActionState.create();
+
+  datasets: DataSpaceDatasetInfo[] = [];
+
+  constructor(dataSpaceViewerState: DataSpaceViewerState) {
+    makeObservable(this, {
+      datasets: observable,
+      fetchDatasetSpecifications: flow,
+      fetchDatasetEntitlementReports: flow,
+    });
+
+    this.dataSpaceViewerState = dataSpaceViewerState;
+  }
+
+  *fetchDatasetSpecifications(): GeneratorFn<void> {
+    this.fetchDatasetSpecificationsState.inProgress();
+
+    try {
+      const datasets =
+        (yield this.dataSpaceViewerState.graphManagerState.graphManager.surveyDatasets(
+          this.dataSpaceViewerState.currentExecutionContext.mapping,
+          this.dataSpaceViewerState.currentExecutionContext.defaultRuntime,
+          undefined,
+          this.dataSpaceViewerState.retriveGraphData(),
+        )) as DatasetSpecification[];
+      this.datasets = datasets.map((dataset) => {
+        const existingDataset = this.datasets.find(
+          (ds) => ds.specification.hashCode === dataset.hashCode,
+        );
+        if (existingDataset) {
+          return existingDataset;
+        }
+        return new DataSpaceDatasetInfo(dataset);
+      });
+    } catch (error) {
+      assertErrorThrown(error);
+      this.dataSpaceViewerState.applicationStore.notificationService.notifyError(
+        error,
+      );
+    } finally {
+      this.fetchDatasetSpecificationsState.complete();
+    }
+  }
+
+  *fetchDatasetEntitlementReports(): GeneratorFn<void> {
+    this.fetchDatasetEntitlementReportsState.inProgress();
+
+    try {
+      const reports =
+        (yield this.dataSpaceViewerState.graphManagerState.graphManager.checkEntitlements(
+          this.dataSpaceViewerState.currentExecutionContext.mapping,
+          this.dataSpaceViewerState.currentExecutionContext.defaultRuntime,
+          undefined,
+          this.dataSpaceViewerState.retriveGraphData(),
+        )) as DatasetEntitlementReport[];
+      this.datasets.forEach((dataset) => {
+        const matchingReport = reports.find(
+          (report) =>
+            report.storeSpecification.hashCode ===
+            dataset.specification.hashCode,
+        );
+        if (matchingReport) {
+          dataset.setEntitlementReport(matchingReport);
+          return;
+        }
+        dataset.setEntitlementReport(undefined);
+      });
+      const newDatasets: DataSpaceDatasetInfo[] = [];
+      reports.forEach((report) => {
+        const matchingDataset = this.datasets.find(
+          (dataset) =>
+            dataset.specification.hashCode ===
+            report.storeSpecification.hashCode,
+        );
+        if (!matchingDataset) {
+          const newDataset = new DataSpaceDatasetInfo(
+            report.storeSpecification,
+          );
+          newDataset.setEntitlementReport(report);
+          newDatasets.push(newDataset);
+        }
+      });
+      this.datasets = this.datasets.concat(newDatasets);
+    } catch (error) {
+      assertErrorThrown(error);
+      this.dataSpaceViewerState.applicationStore.notificationService.notifyError(
+        error,
+      );
+    } finally {
+      this.fetchDatasetEntitlementReportsState.complete();
+    }
+  }
+}