@finos/legend-graph 5.0.0 → 6.0.0

package/src/graphManager/EmbeddedData_PureGraphManagerPlugin_Extension.ts

@@ -0,0 +1,29 @@
+/**
+ * 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 { EmbeddedData } from '../models/metamodels/pure/data/EmbeddedData';
+import type { ObserverContext } from './action/changeDetection/CoreObserverHelper';
+import type { PureGraphManagerPlugin } from './PureGraphManagerPlugin';
+
+export type EmbeddedDataObserver = (
+  embeddedData: EmbeddedData,
+  context: ObserverContext,
+) => EmbeddedData | undefined;
+
+export interface EmbeddedData_PureGraphManagerPlugin_Extension
+  extends PureGraphManagerPlugin {
+  getExtraEmbeddedDataObservers?(): EmbeddedDataObserver[];
+}

package/src/graphManager/GraphManagerEvent.ts

@@ -23,6 +23,7 @@ export enum GRAPH_MANAGER_EVENT {
   GRAPH_BUILDER_MAPPINGS_BUILT = 'GRAPH_BUILDER_MAPPINGS_BUILT',
   GRAPH_BUILDER_CONNECTIONS_AND_RUNTIMES_BUILT = 'GRAPH_BUILDER_CONNECTIONS_AND_RUNTIMES_BUILT',
   GRAPH_BUILDER_SERVICES_BUILT = 'GRAPH_BUILDER_SERVICES_BUILT',
+  GRAPH_BUILDER_DATA_ELEMENTS_BUILT = 'GRAPH_BUILDER_DATA_ELEMENTS_BUILT',
   GRAPH_BUILDER_OTHER_ELEMENTS_BUILT = 'GRAPH_BUILDER_OTHER_ELEMENTS_BUILT',
   GRAPH_BUILDER_COMPLETED = 'GRAPH_BUILDER_COMPLETED',
 

package/src/graphManager/PureGraphManagerPlugin.ts

@@ -27,7 +27,6 @@ import type { ObserverContext } from './action/changeDetection/CoreObserverHelpe
 export type PureGrammarElementLabeler = (
   metamodel: PackageableElement,
 ) => string | undefined;
-
 export type ElementObserver = (
   metamodel: PackageableElement,
   context: ObserverContext,
@@ -44,21 +43,6 @@ export abstract class PureGraphManagerPlugin extends AbstractPlugin {
     pluginManager.registerPureGraphManagerPlugin(this);
   }
 
-  /**
-   * Get the list of supported Pure grammar parsers.
-   */
-  getExtraPureGrammarParserNames?(): string[];
-
-  /**
-   * Get the list of supported Pure grammar keywords.
-   */
-  getExtraPureGrammarKeywords?(): string[];
-
-  /**
-   * Get the list of Pure grammar type labelers for packageable elements.
-   */
-  getExtraPureGrammarElementLabelers?(): PureGrammarElementLabeler[];
-
   /**
    * Get the list of system element qualified paths to be exposed for common usages.
    *
@@ -74,4 +58,19 @@ export abstract class PureGraphManagerPlugin extends AbstractPlugin {
    * become observable by change detection engine.
    */
   getExtraElementObservers?(): ElementObserver[];
+
+  /**
+   * Get the list of supported Pure grammar parsers.
+   */
+  getExtraPureGrammarParserNames?(): string[];
+
+  /**
+   * Get the list of supported Pure grammar keywords.
+   */
+  getExtraPureGrammarKeywords?(): string[];
+
+  /**
+   * Get the list of Pure grammar element labelers.
+   */
+  getExtraPureGrammarElementLabelers?(): PureGrammarElementLabeler[];
 }

package/src/graphManager/action/changeDetection/DSLService_ObserverHelper.ts

@@ -23,13 +23,7 @@ import {
   PureMultiExecution,
   PureSingleExecution,
 } from '../../../models/metamodels/pure/packageableElements/service/ServiceExecution';
-import {
-  type ServiceTest,
-  type KeyedSingleExecutionTest,
-  type TestContainer,
-  MultiExecutionTest,
-  SingleExecutionTest,
-} from '../../../models/metamodels/pure/packageableElements/service/ServiceTest';
+import type { ServiceTest } from '../../../models/metamodels/pure/packageableElements/service/ServiceTest';
 import {
   observe_Abstract_PackageableElement,
   observe_PackageableElementReference,
@@ -43,9 +37,102 @@ import {
 } from './DomainObserverHelper';
 import { observe_RawLambda } from './RawValueSpecificationObserver';
 import { observe_Runtime } from './DSLMapping_ObserverHelper';
+import type { ConnectionTestData } from '../../../models/metamodels/pure/packageableElements/service/ConnectionTestData';
+import { observe_EmbeddedData } from './Data_ObserverHelper';
+import type { ParameterValue } from '../../../models/metamodels/pure/packageableElements/service/ParameterValue';
+import {
+  type DEPRECATED__ServiceTest,
+  type DEPRECATED__KeyedSingleExecutionTest,
+  type DEPRECATED__TestContainer,
+  DEPRECATED__MultiExecutionTest,
+  DEPRECATED__SingleExecutionTest,
+} from '../../../models/metamodels/pure/packageableElements/service/DEPRECATED__ServiceTest';
+import type { ServiceTestSuite } from '../../../models/metamodels/pure/packageableElements/service/ServiceTestSuite';
+import type { TestData } from '../../../models/metamodels/pure/packageableElements/service/ServiceTestData';
+import {
+  observe_AtomicTest,
+  observe_TestAssertion,
+  observe_TestSuite,
+} from './Test_ObserverHelper';
+
+export const observe_ConnectionTestData = skipObservedWithContext(
+  (
+    metamodel: ConnectionTestData,
+    context: ObserverContext,
+  ): ConnectionTestData => {
+    makeObservable(metamodel, {
+      connectionId: observable,
+      testData: observable,
+      hashCode: computed,
+    });
+
+    observe_EmbeddedData(metamodel.testData, context);
+
+    return metamodel;
+  },
+);
+
+export const observe_ParameterValue = skipObserved(
+  (metamodel: ParameterValue): ParameterValue => {
+    makeObservable(metamodel, {
+      name: observable,
+      value: observable,
+      hashCode: computed,
+    });
+
+    return metamodel;
+  },
+);
+
+export const observe_TestData = skipObservedWithContext(
+  (metamodel: TestData, context: ObserverContext): TestData => {
+    makeObservable(metamodel, {
+      connectionsTestData: observable,
+      hashCode: computed,
+    });
+
+    metamodel.connectionsTestData.forEach((connectionTestData) =>
+      observe_ConnectionTestData(connectionTestData, context),
+    );
+
+    return metamodel;
+  },
+);
+
+export const observe_ServiceTest = skipObserved(
+  (metamodel: ServiceTest): ServiceTest => {
+    makeObservable(metamodel, {
+      id: observable,
+      assertions: observable,
+      parameters: observable,
+      hashCode: computed,
+    });
+
+    metamodel.parameters.forEach(observe_ParameterValue);
+    metamodel.assertions.forEach(observe_TestAssertion);
+
+    return metamodel;
+  },
+);
+
+export const observe_ServiceTestSuite = skipObservedWithContext(
+  (metamodel: ServiceTestSuite, context: ObserverContext): ServiceTestSuite => {
+    makeObservable(metamodel, {
+      id: observable,
+      tests: observable,
+      testData: observable,
+      hashCode: computed,
+    });
+
+    metamodel.tests.forEach(observe_AtomicTest);
+    observe_TestData(metamodel.testData, context);
+
+    return metamodel;
+  },
+);
 
 export const observe_TestContainer = skipObserved(
-  (metamodel: TestContainer): TestContainer => {
+  (metamodel: DEPRECATED__TestContainer): DEPRECATED__TestContainer => {
     makeObservable(metamodel, {
       parametersValues: observable,
       assert: observable,
@@ -60,7 +147,9 @@ export const observe_TestContainer = skipObserved(
 );
 
 export const observe_SingleExecutionTest = skipObserved(
-  (metamodel: SingleExecutionTest): SingleExecutionTest => {
+  (
+    metamodel: DEPRECATED__SingleExecutionTest,
+  ): DEPRECATED__SingleExecutionTest => {
     makeObservable(metamodel, {
       data: observable,
       asserts: observable,
@@ -74,7 +163,9 @@ export const observe_SingleExecutionTest = skipObserved(
 );
 
 export const observe_KeyedSingleExecutionTest = skipObserved(
-  (metamodel: KeyedSingleExecutionTest): KeyedSingleExecutionTest => {
+  (
+    metamodel: DEPRECATED__KeyedSingleExecutionTest,
+  ): DEPRECATED__KeyedSingleExecutionTest => {
     observe_SingleExecutionTest(metamodel);
 
     makeObservable(metamodel, {
@@ -86,7 +177,9 @@ export const observe_KeyedSingleExecutionTest = skipObserved(
 );
 
 export const observe_MultiExecutionTest = skipObserved(
-  (metamodel: MultiExecutionTest): MultiExecutionTest => {
+  (
+    metamodel: DEPRECATED__MultiExecutionTest,
+  ): DEPRECATED__MultiExecutionTest => {
     makeObservable(metamodel, {
       tests: observable,
       hashCode: computed,
@@ -98,10 +191,12 @@ export const observe_MultiExecutionTest = skipObserved(
   },
 );
 
-export const observe_ServiceTest = (metamodel: ServiceTest): ServiceTest => {
-  if (metamodel instanceof SingleExecutionTest) {
+export const observe_ServiceTest_Legacy = (
+  metamodel: DEPRECATED__ServiceTest,
+): DEPRECATED__ServiceTest => {
+  if (metamodel instanceof DEPRECATED__SingleExecutionTest) {
     return observe_SingleExecutionTest(metamodel);
-  } else if (metamodel instanceof MultiExecutionTest) {
+  } else if (metamodel instanceof DEPRECATED__MultiExecutionTest) {
     return observe_MultiExecutionTest(metamodel);
   }
   return metamodel;
@@ -190,6 +285,7 @@ export const observe_Service = skipObservedWithContext(
       autoActivateUpdates: observable,
       execution: observable,
       test: observable,
+      tests: observable,
       patternParameters: computed,
       _elementHashCode: override,
     });
@@ -197,7 +293,12 @@ export const observe_Service = skipObservedWithContext(
     metamodel.stereotypes.forEach(observe_StereotypeReference);
     metamodel.taggedValues.forEach(observe_TaggedValue);
     observe_ServiceExecution(metamodel.execution, context);
-    observe_ServiceTest(metamodel.test);
+    if (metamodel.test) {
+      observe_ServiceTest_Legacy(metamodel.test);
+    }
+    metamodel.tests.forEach((testSuite) =>
+      observe_TestSuite(testSuite, context),
+    );
 
     return metamodel;
   },

package/src/graphManager/action/changeDetection/Data_ObserverHelper.ts

@@ -0,0 +1,112 @@
+/**
+ * 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 { computed, makeObservable, observable, override } from 'mobx';
+import {
+  type EmbeddedData,
+  ExternalFormatData,
+  DataElementReference,
+  ModelStoreData,
+} from '../../../models/metamodels/pure/data/EmbeddedData';
+import type { DataElement } from '../../../models/metamodels/pure/packageableElements/data/DataElement';
+import type { EmbeddedData_PureGraphManagerPlugin_Extension } from '../../EmbeddedData_PureGraphManagerPlugin_Extension';
+import {
+  type ObserverContext,
+  observe_Abstract_PackageableElement,
+  skipObserved,
+  skipObservedWithContext,
+} from './CoreObserverHelper';
+import {
+  observe_StereotypeReference,
+  observe_TaggedValue,
+} from './DomainObserverHelper';
+
+export const observe_ExternalFormatData = skipObserved(
+  (metamodel: ExternalFormatData): ExternalFormatData => {
+    makeObservable(metamodel, {
+      contentType: observable,
+      data: observable,
+      hashCode: computed,
+    });
+
+    return metamodel;
+  },
+);
+
+export const observe_DataElementReference = skipObserved(
+  (metamodel: DataElementReference): DataElementReference => {
+    makeObservable(metamodel, {
+      dataElement: observable,
+      hashCode: computed,
+    });
+
+    return metamodel;
+  },
+);
+
+export const observe_ModelStoreData = skipObserved(
+  (metamodel: ModelStoreData): ModelStoreData => {
+    makeObservable(metamodel, {
+      instances: observable,
+      hashCode: computed,
+    });
+
+    return metamodel;
+  },
+);
+
+export function observe_EmbeddedData(
+  metamodel: EmbeddedData,
+  context: ObserverContext,
+): EmbeddedData {
+  if (metamodel instanceof DataElementReference) {
+    return observe_DataElementReference(metamodel);
+  } else if (metamodel instanceof ExternalFormatData) {
+    return observe_ExternalFormatData(metamodel);
+  } else if (metamodel instanceof ModelStoreData) {
+    return observe_ModelStoreData(metamodel);
+  }
+  const extraEmbeddedDataObservers = context.plugins.flatMap(
+    (plugin) =>
+      (
+        plugin as EmbeddedData_PureGraphManagerPlugin_Extension
+      ).getExtraEmbeddedDataObservers?.() ?? [],
+  );
+  for (const observer of extraEmbeddedDataObservers) {
+    const observedEmbeddedData = observer(metamodel, context);
+    if (observedEmbeddedData) {
+      return observedEmbeddedData;
+    }
+  }
+  return metamodel;
+}
+
+export const observe_DataElement = skipObservedWithContext(
+  (metamodel: DataElement, context: ObserverContext): DataElement => {
+    observe_Abstract_PackageableElement(metamodel);
+
+    makeObservable<DataElement, '_elementHashCode'>(metamodel, {
+      stereotypes: observable,
+      taggedValues: observable,
+      data: observable,
+      _elementHashCode: override,
+    });
+    metamodel.stereotypes.forEach(observe_StereotypeReference);
+    metamodel.taggedValues.forEach(observe_TaggedValue);
+    observe_EmbeddedData(metamodel.data, context);
+    return metamodel;
+  },
+);

package/src/graphManager/action/changeDetection/GraphObserverHelper.ts

@@ -33,10 +33,7 @@ const observe_PureGraphExtension = skipObserved(
     }),
 );
 
-const observe_Abstract_BasicModel = async (
-  metamodel: BasicModel,
-  context: ObserverContext,
-): Promise<void> => {
+const observe_Abstract_BasicModel = (metamodel: BasicModel): void => {
   makeObservable<
     BasicModel,
     | 'elementSectionMap'
@@ -52,7 +49,7 @@ const observe_Abstract_BasicModel = async (
     | 'servicesIndex'
     | 'generationSpecificationsIndex'
     | 'fileGenerationsIndex'
-    | 'extensions'
+    | 'dataElementsIndex'
   >(metamodel, {
     elementSectionMap: observable,
     sectionIndicesIndex: observable,
@@ -67,8 +64,10 @@ const observe_Abstract_BasicModel = async (
     servicesIndex: observable,
     generationSpecificationsIndex: observable,
     fileGenerationsIndex: observable,
+    dataElementsIndex: observable,
     extensions: observable,
 
+    allOwnElements: computed,
     ownSectionIndices: computed,
     ownProfiles: computed,
     ownEnumerations: computed,
@@ -86,18 +85,9 @@ const observe_Abstract_BasicModel = async (
     ownConnections: computed,
     ownFileGenerations: computed,
     ownGenerationSpecifications: computed,
-    allOwnElements: computed,
+    ownDataElements: computed,
   });
 
-  /**
-   * A note on performance here. We could observe the package tree recursively synchronously
-   * we have tried before and it does not take a long time, but at the risk of
-   * blocking the main thread, we parallize this anyway
-   *
-   * We have tried to traversed all the elements and observe them before, but that ends up
-   * being slower than just recursively going through the package tree.
-   */
-  await observe_PackageTree(metamodel.root, context);
   metamodel.extensions.forEach(observe_PureGraphExtension);
 };
 
@@ -108,6 +98,7 @@ export const observe_DependencyManager = skipObserved(
       projectDependencyModelsIndex: observable,
       allOwnElements: computed,
       dependencyGraphs: computed,
+      sectionIndices: computed,
       profiles: computed,
       enumerations: computed,
       measures: computed,
@@ -121,20 +112,31 @@ export const observe_DependencyManager = skipObserved(
       services: computed,
       runtimes: computed,
       connections: computed,
-      fileGenerations: computed,
       generationSpecifications: computed,
-      sectionIndices: computed,
+      fileGenerations: computed,
+      dataElements: computed,
     }),
 );
 
-export const observe_Graph = async (
-  metamodel: PureModel,
-  context: ObserverContext,
-): Promise<PureModel> => {
+/**
+ * NOTE: when we observe the graph, it is important to do this synchronously
+ * to not mess with `mobx`. Since most of the indices of the graph are computed values
+ * we have seen cases where asynchronousity hurts us and causes really ellusive bugs
+ * since `mobx` observabilty does not track in asynchronous context and `makeObservable`
+ * is sort of equivalent to triggering observability.
+ *
+ * See https://mobx.js.org/understanding-reactivity.html#understanding-reactivity
+ * See https://github.com/finos/legend-studio/issues/1121
+ *
+ * On the other hand, for performance purpose, we would need to observe all of graph
+ * elements asynchronously, as such, we would do that separately in the method
+ * {@link observe_GraphElements}
+ */
+export const observe_Graph = (metamodel: PureModel): PureModel => {
   if (isObservable(metamodel)) {
     return metamodel;
   }
-  await observe_Abstract_BasicModel(metamodel, context);
+  observe_Abstract_BasicModel(metamodel);
 
   makeObservable(metamodel, {
     generationModel: observable,
@@ -145,3 +147,21 @@ export const observe_Graph = async (
 
   return metamodel;
 };
+
+/**
+ * This method is designed for performance purpose.
+ *
+ * NOTE: this might have some impact on `mobx` observability, see the note
+ * of {@link observe_Graph}
+ */
+export const observe_GraphElements = async (
+  metamodel: PureModel,
+  context: ObserverContext,
+): Promise<void> => {
+  /**
+   * A note on performance here. We could observe the package tree recursively synchronously
+   * we have tried before and it does not take a long time, but at the risk of
+   * blocking the main thread, we parallize this anyway, hence we must make this method asynchronous.
+   */
+  await observe_PackageTree(metamodel.root, context);
+};

package/src/graphManager/action/changeDetection/PackageableElementObserver.ts

@@ -61,6 +61,8 @@ import {
 import { observe_Service } from './DSLService_ObserverHelper';
 import { observe_FlatData } from './StoreFlatData_ObserverHelper';
 import { observe_Database } from './StoreRelational_ObserverHelper';
+import type { DataElement } from '../../../models/metamodels/pure/packageableElements/data/DataElement';
+import { observe_DataElement } from './Data_ObserverHelper';
 
 class PackageableElementObserver implements PackageableElementVisitor<void> {
   observerContext: ObserverContext;
@@ -150,6 +152,10 @@ class PackageableElementObserver implements PackageableElementVisitor<void> {
   visit_GenerationSpecification(element: GenerationSpecification): void {
     observe_GenerationSpecification(element);
   }
+
+  visit_DataElement(element: DataElement): void {
+    observe_DataElement(element, this.observerContext);
+  }
 }
 
 export const observe_PackageableElement = skipObservedWithContext(