@finos/legend-graph 2.1.3 → 4.0.1

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

@@ -0,0 +1,519 @@
+/**
+ * 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,
+  isObservable,
+  makeObservable,
+  observable,
+  override,
+} from 'mobx';
+import type { Association } from '../../../models/metamodels/pure/packageableElements/domain/Association';
+import { Class } from '../../../models/metamodels/pure/packageableElements/domain/Class';
+import type { ConcreteFunctionDefinition } from '../../../models/metamodels/pure/packageableElements/domain/ConcreteFunctionDefinition';
+import type { Constraint } from '../../../models/metamodels/pure/packageableElements/domain/Constraint';
+import type { DataType } from '../../../models/metamodels/pure/packageableElements/domain/DataType';
+import type { DerivedProperty } from '../../../models/metamodels/pure/packageableElements/domain/DerivedProperty';
+import type { Enum } from '../../../models/metamodels/pure/packageableElements/domain/Enum';
+import { Enumeration } from '../../../models/metamodels/pure/packageableElements/domain/Enumeration';
+import type { EnumValueReference } from '../../../models/metamodels/pure/packageableElements/domain/EnumValueReference';
+import type { GenericType } from '../../../models/metamodels/pure/packageableElements/domain/GenericType';
+import type { GenericTypeReference } from '../../../models/metamodels/pure/packageableElements/domain/GenericTypeReference';
+import {
+  Measure,
+  Unit,
+} from '../../../models/metamodels/pure/packageableElements/domain/Measure';
+import { Package } from '../../../models/metamodels/pure/packageableElements/domain/Package';
+import type { Profile } from '../../../models/metamodels/pure/packageableElements/domain/Profile';
+import type { Property } from '../../../models/metamodels/pure/packageableElements/domain/Property';
+import type { PropertyReference } from '../../../models/metamodels/pure/packageableElements/domain/PropertyReference';
+import type { Stereotype } from '../../../models/metamodels/pure/packageableElements/domain/Stereotype';
+import type { StereotypeReference } from '../../../models/metamodels/pure/packageableElements/domain/StereotypeReference';
+import type { Tag } from '../../../models/metamodels/pure/packageableElements/domain/Tag';
+import type { TaggedValue } from '../../../models/metamodels/pure/packageableElements/domain/TaggedValue';
+import type { TagReference } from '../../../models/metamodels/pure/packageableElements/domain/TagReference';
+import type { Type } from '../../../models/metamodels/pure/packageableElements/domain/Type';
+import {
+  DefaultCodeSection,
+  ImportAwareCodeSection,
+  type Section,
+} from '../../../models/metamodels/pure/packageableElements/section/Section';
+import type { SectionIndex } from '../../../models/metamodels/pure/packageableElements/section/SectionIndex';
+import {
+  observe_Multiplicity,
+  observe_Abstract_PackageableElement,
+  observe_PackageableElementReference,
+  skipObserved,
+  skipObservedWithContext,
+  type ObserverContext,
+} from './CoreObserverHelper';
+import { observe_PackageabElement } from './PackageableElementObserver';
+import {
+  observe_RawLambda,
+  observe_RawVariableExpression,
+} from './RawValueSpecificationObserver';
+
+const _observe_Abstract_Package = (metamodel: Package): void => {
+  observe_Abstract_PackageableElement(metamodel);
+
+  makeObservable(metamodel, {
+    children: observable,
+    hashCode: override,
+  });
+};
+
+/**
+ * NOTE: here we try to be consistent by recrusively going down the package tree
+ * and observe all descendents.
+ */
+export const observe_Package = skipObservedWithContext(
+  (metamodel: Package, context): Package => {
+    _observe_Abstract_Package(metamodel);
+
+    metamodel.children.forEach((child) => {
+      if (child instanceof Package) {
+        observe_Package(child, context);
+      } else {
+        observe_PackageabElement(child, context);
+      }
+    });
+
+    return metamodel;
+  },
+);
+
+export const observe_PackageTree = async (
+  metamodel: Package,
+  context: ObserverContext,
+): Promise<Package> => {
+  if (isObservable(metamodel)) {
+    return metamodel;
+  }
+
+  _observe_Abstract_Package(metamodel);
+
+  await Promise.all(
+    metamodel.children.map(async (child) => {
+      if (child instanceof Package) {
+        await observe_PackageTree(child, context);
+      } else {
+        observe_PackageabElement(child, context);
+      }
+    }),
+  );
+
+  return metamodel;
+};
+
+export const observe_StereotypeReference = skipObserved(
+  (metamodel: StereotypeReference): StereotypeReference => {
+    makeObservable(metamodel, {
+      value: observable,
+      isStub: computed,
+      pointerHashCode: computed,
+    });
+
+    observe_PackageableElementReference(metamodel.ownerReference);
+
+    return metamodel;
+  },
+);
+
+export const observe_TagReference = skipObserved(
+  (metamodel: TagReference): TagReference => {
+    makeObservable(metamodel, {
+      value: observable,
+      isStub: computed,
+      pointerHashCode: computed,
+    });
+
+    return metamodel;
+  },
+);
+
+export const observe_TaggedValue = skipObserved(
+  (metamodel: TaggedValue): TaggedValue => {
+    makeObservable(metamodel, {
+      value: observable,
+      isStub: computed,
+      hashCode: computed,
+    });
+
+    observe_TagReference(metamodel.tag);
+
+    return metamodel;
+  },
+);
+
+export const observe_GenericTypeReference = skipObserved(
+  (metamodel: GenericTypeReference): GenericTypeReference => {
+    makeObservable(metamodel, {
+      value: observable,
+      isStub: computed,
+    });
+
+    observe_PackageableElementReference(metamodel.ownerReference);
+
+    return metamodel;
+  },
+);
+
+// ------------------------------------- Section Index -------------------------------------
+
+export const observe_Section = skipObserved((metamodel: Section): Section => {
+  makeObservable(metamodel, {
+    parent: observable,
+    parserName: observable,
+    elements: observable,
+  });
+
+  if (metamodel instanceof ImportAwareCodeSection) {
+    makeObservable(metamodel, {
+      imports: observable,
+      hashCode: computed,
+    });
+  } else if (metamodel instanceof DefaultCodeSection) {
+    makeObservable(metamodel, {
+      hashCode: computed,
+    });
+  }
+  return metamodel;
+});
+
+export const observe_SectionIndex = skipObserved(
+  (metamodel: SectionIndex): SectionIndex => {
+    observe_Abstract_PackageableElement(metamodel);
+
+    makeObservable<SectionIndex, '_elementHashCode'>(metamodel, {
+      sections: observable,
+      _elementHashCode: override,
+    });
+
+    metamodel.sections.forEach(observe_Section);
+
+    return metamodel;
+  },
+);
+
+// ------------------------------------- Profile -------------------------------------
+
+export const observe_Stereotype = skipObserved(
+  (metamodel: Stereotype): Stereotype =>
+    makeObservable(metamodel, {
+      value: observable,
+      isStub: computed,
+    }),
+);
+
+export const observe_Tag = skipObserved(
+  (metamodel: Tag): Tag =>
+    makeObservable(metamodel, {
+      value: observable,
+      isStub: computed,
+    }),
+);
+
+export const observe_Profile = skipObserved((metamodel: Profile): Profile => {
+  observe_Abstract_PackageableElement(metamodel);
+
+  makeObservable<Profile, '_elementHashCode'>(metamodel, {
+    stereotypes: observable,
+    tags: observable,
+    isStub: computed,
+    _elementHashCode: override,
+  });
+
+  metamodel.stereotypes.forEach(observe_Stereotype);
+  metamodel.tags.forEach(observe_Tag);
+
+  return metamodel;
+});
+
+// ------------------------------------- Enumeration -------------------------------------
+
+export const observe_Enum = skipObserved((metamodel: Enum): Enum => {
+  makeObservable(metamodel, {
+    name: observable,
+    stereotypes: observable,
+    taggedValues: observable,
+    isStub: computed,
+    hashCode: computed,
+  });
+
+  metamodel.stereotypes.forEach(observe_StereotypeReference);
+  metamodel.taggedValues.forEach(observe_TaggedValue);
+
+  return metamodel;
+});
+
+export const observe_EnumValueReference = skipObserved(
+  (metamodel: EnumValueReference): EnumValueReference => {
+    makeObservable(metamodel, {
+      value: observable,
+      isStub: computed,
+    });
+
+    observe_PackageableElementReference(metamodel.ownerReference);
+
+    return metamodel;
+  },
+);
+
+export const observe_Enumeration = skipObserved(
+  (metamodel: Enumeration): Enumeration => {
+    observe_Abstract_PackageableElement(metamodel);
+
+    makeObservable<Enumeration, '_elementHashCode'>(metamodel, {
+      values: observable,
+      stereotypes: observable,
+      taggedValues: observable,
+      isStub: computed,
+      _elementHashCode: override,
+    });
+
+    metamodel.values.forEach(observe_Enum);
+    metamodel.stereotypes.forEach(observe_StereotypeReference);
+    metamodel.taggedValues.forEach(observe_TaggedValue);
+
+    return metamodel;
+  },
+);
+
+// ------------------------------------- Measure -------------------------------------
+
+export const observe_Unit = skipObserved((metamodel: Unit): Unit => {
+  makeObservable(metamodel, {
+    measure: observable,
+    conversionFunction: observable,
+    hashCode: override,
+  });
+
+  if (metamodel.conversionFunction) {
+    observe_RawLambda(metamodel.conversionFunction);
+  }
+
+  return metamodel;
+});
+
+export const observe_Measure = skipObserved((metamodel: Measure): Measure => {
+  observe_Abstract_PackageableElement(metamodel);
+
+  makeObservable<Measure, '_elementHashCode'>(metamodel, {
+    canonicalUnit: observable,
+    nonCanonicalUnits: observable,
+    _elementHashCode: override,
+  });
+
+  if (metamodel.canonicalUnit) {
+    observe_Unit(metamodel.canonicalUnit);
+  }
+  metamodel.nonCanonicalUnits.forEach(observe_Unit);
+
+  return metamodel;
+});
+
+// ------------------------------------- Class -------------------------------------
+
+export const observe_Property = skipObserved(
+  (metamodel: Property): Property => {
+    makeObservable(metamodel, {
+      name: observable,
+      multiplicity: observable,
+      stereotypes: observable,
+      taggedValues: observable,
+      isStub: computed,
+      hashCode: computed,
+    });
+
+    observe_GenericTypeReference(metamodel.genericType);
+    observe_Multiplicity(metamodel.multiplicity);
+    metamodel.stereotypes.forEach(observe_StereotypeReference);
+    metamodel.taggedValues.forEach(observe_TaggedValue);
+
+    return metamodel;
+  },
+);
+
+export const observe_DerivedProperty = skipObserved(
+  (metamodel: DerivedProperty): DerivedProperty => {
+    makeObservable(metamodel, {
+      name: observable,
+      multiplicity: observable,
+      stereotypes: observable,
+      taggedValues: observable,
+      body: observable.ref, // only observe the reference, the object itself is not observed
+      parameters: observable.ref, // only observe the reference, the object itself is not observed
+      isStub: computed,
+      hashCode: computed,
+    });
+
+    observe_GenericTypeReference(metamodel.genericType);
+    observe_Multiplicity(metamodel.multiplicity);
+    metamodel.stereotypes.forEach(observe_StereotypeReference);
+    metamodel.taggedValues.forEach(observe_TaggedValue);
+
+    return metamodel;
+  },
+);
+
+export const observe_PropertyReference = skipObserved(
+  (metamodel: PropertyReference): PropertyReference => {
+    makeObservable(metamodel, {
+      value: observable,
+      isStub: computed,
+      pointerHashCode: computed,
+    });
+
+    observe_PackageableElementReference(metamodel.ownerReference);
+
+    return metamodel;
+  },
+);
+
+export const observe_Constraint = skipObserved(
+  (metamodel: Constraint): Constraint => {
+    makeObservable(metamodel, {
+      name: observable,
+      functionDefinition: observable,
+      externalId: observable,
+      enforcementLevel: observable,
+      messageFunction: observable,
+      isStub: computed,
+      hashCode: computed,
+    });
+
+    observe_RawLambda(metamodel.functionDefinition);
+
+    if (metamodel.messageFunction) {
+      observe_RawLambda(metamodel.messageFunction);
+    }
+
+    return metamodel;
+  },
+);
+
+export const observe_Class = skipObserved((metamodel: Class): Class => {
+  observe_Abstract_PackageableElement(metamodel);
+
+  makeObservable<Class, '_elementHashCode'>(metamodel, {
+    properties: observable,
+    propertiesFromAssociations: observable,
+    derivedProperties: observable,
+    generalizations: observable,
+    subclasses: observable,
+    constraints: observable,
+    stereotypes: observable,
+    taggedValues: observable,
+    allSuperclasses: computed,
+    allSubclasses: computed,
+    dispose: override,
+    isStub: computed,
+    _elementHashCode: override,
+  });
+
+  metamodel.properties.forEach(observe_Property);
+  metamodel.propertiesFromAssociations.forEach(observe_Property);
+  metamodel.derivedProperties.forEach(observe_DerivedProperty);
+  metamodel.generalizations.forEach(observe_GenericTypeReference);
+  metamodel.constraints.forEach(observe_Constraint);
+  metamodel.stereotypes.forEach(observe_StereotypeReference);
+  metamodel.taggedValues.forEach(observe_TaggedValue);
+
+  return metamodel;
+});
+
+// ------------------------------------- Association -------------------------------------
+
+export const observe_Association = skipObserved(
+  (metamodel: Association): Association => {
+    observe_Abstract_PackageableElement(metamodel);
+
+    makeObservable<Association, '_elementHashCode'>(metamodel, {
+      properties: observable,
+      stereotypes: observable,
+      taggedValues: observable,
+      derivedProperties: observable,
+      isStub: computed,
+      _elementHashCode: override,
+    });
+
+    metamodel.properties.forEach(observe_Property);
+    metamodel.derivedProperties.forEach(observe_DerivedProperty);
+    metamodel.stereotypes.forEach(observe_StereotypeReference);
+    metamodel.taggedValues.forEach(observe_TaggedValue);
+
+    return metamodel;
+  },
+);
+
+// ------------------------------------- Function -------------------------------------
+
+export const observe_ConcreteFunctionDefinition = skipObserved(
+  (metamodel: ConcreteFunctionDefinition): ConcreteFunctionDefinition => {
+    observe_Abstract_PackageableElement(metamodel);
+
+    makeObservable<ConcreteFunctionDefinition, '_elementHashCode'>(metamodel, {
+      returnMultiplicity: observable,
+      parameters: observable.shallow, // only observe the list structure, each object itself is not observed
+      body: observable.ref, // only observe the reference, the object itself is not observed
+      stereotypes: observable,
+      taggedValues: observable,
+      _elementHashCode: override,
+    });
+
+    metamodel.parameters.forEach(observe_RawVariableExpression);
+    observe_PackageableElementReference(metamodel.returnType);
+    observe_Multiplicity(metamodel.returnMultiplicity);
+    metamodel.stereotypes.forEach(observe_StereotypeReference);
+    metamodel.taggedValues.forEach(observe_TaggedValue);
+
+    return metamodel;
+  },
+);
+
+// ------------------------------------- Type -------------------------------------
+
+export const observe_Type = skipObserved((metamodel: Type): Type => {
+  if (metamodel instanceof Enumeration) {
+    return observe_Enumeration(metamodel);
+  } else if (metamodel instanceof Unit) {
+    return observe_Unit(metamodel);
+  } else if (metamodel instanceof Class) {
+    return observe_Class(metamodel);
+  } else if (metamodel instanceof Measure) {
+    return observe_Measure(metamodel);
+  }
+  return metamodel;
+});
+
+export const observe_DataType = skipObserved(
+  (metamodel: DataType): DataType => {
+    if (metamodel instanceof Enumeration) {
+      return observe_Enumeration(metamodel);
+    } else if (metamodel instanceof Unit) {
+      return observe_Unit(metamodel);
+    }
+    return metamodel;
+  },
+);
+
+export const observe_GenericType = skipObserved(
+  (metamodel: GenericType): GenericType =>
+    makeObservable(metamodel, {
+      rawType: observable,
+      isStub: computed,
+    }),
+);

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

@@ -0,0 +1,149 @@
+/**
+ * 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, isObservable, makeObservable, observable } from 'mobx';
+import type { BasicModel } from '../../../graph/BasicModel';
+import type { DependencyManager } from '../../../graph/DependencyManager';
+import type { PureGraphExtension } from '../../../graph/PureGraphExtension';
+import type { PureModel } from '../../../graph/PureModel';
+import type { PackageableElement } from '../../../models/metamodels/pure/packageableElements/PackageableElement';
+import { type ObserverContext, skipObserved } from './CoreObserverHelper';
+import { observe_PackageTree } from './DomainObserverHelper';
+
+const observe_PureGraphExtension = skipObserved(
+  <T extends PackageableElement>(
+    metamodel: PureGraphExtension<T>,
+  ): PureGraphExtension<T> =>
+    makeObservable<PureGraphExtension<T>, 'index'>(metamodel, {
+      index: observable,
+      elements: computed,
+    }),
+);
+
+const observe_Abstract_BasicModel = async (
+  metamodel: BasicModel,
+  context: ObserverContext,
+): Promise<void> => {
+  makeObservable<
+    BasicModel,
+    | 'elementSectionMap'
+    | 'sectionIndicesIndex'
+    | 'profilesIndex'
+    | 'typesIndex'
+    | 'associationsIndex'
+    | 'functionsIndex'
+    | 'storesIndex'
+    | 'mappingsIndex'
+    | 'connectionsIndex'
+    | 'runtimesIndex'
+    | 'servicesIndex'
+    | 'generationSpecificationsIndex'
+    | 'fileGenerationsIndex'
+    | 'extensions'
+  >(metamodel, {
+    elementSectionMap: observable,
+    sectionIndicesIndex: observable,
+    profilesIndex: observable,
+    typesIndex: observable,
+    associationsIndex: observable,
+    functionsIndex: observable,
+    storesIndex: observable,
+    mappingsIndex: observable,
+    connectionsIndex: observable,
+    runtimesIndex: observable,
+    servicesIndex: observable,
+    generationSpecificationsIndex: observable,
+    fileGenerationsIndex: observable,
+    extensions: observable,
+
+    ownSectionIndices: computed,
+    ownProfiles: computed,
+    ownEnumerations: computed,
+    ownMeasures: computed,
+    ownUnits: computed,
+    ownClasses: computed,
+    ownTypes: computed,
+    ownAssociations: computed,
+    ownFunctions: computed,
+    ownStores: computed,
+    ownFlatDatas: computed,
+    ownDatabases: computed,
+    ownMappings: computed,
+    ownServices: computed,
+    ownRuntimes: computed,
+    ownConnections: computed,
+    ownFileGenerations: computed,
+    ownGenerationSpecifications: computed,
+    allOwnElements: 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);
+};
+
+export const observe_DependencyManager = skipObserved(
+  (metamodel: DependencyManager): DependencyManager =>
+    makeObservable(metamodel, {
+      root: observable,
+      projectDependencyModelsIndex: observable,
+      allElements: computed,
+      models: computed,
+      profiles: computed,
+      enumerations: computed,
+      measures: computed,
+      units: computed,
+      classes: computed,
+      types: computed,
+      associations: computed,
+      functions: computed,
+      stores: computed,
+      databases: computed,
+      mappings: computed,
+      services: computed,
+      runtimes: computed,
+      connections: computed,
+      fileGenerations: computed,
+      generationSpecifications: computed,
+      sectionIndices: computed,
+    }),
+);
+
+export const observe_PureModel = async (
+  metamodel: PureModel,
+  context: ObserverContext,
+): Promise<PureModel> => {
+  if (isObservable(metamodel)) {
+    return metamodel;
+  }
+  await observe_Abstract_BasicModel(metamodel, context);
+
+  makeObservable(metamodel, {
+    generationModel: observable,
+    dependencyManager: observable,
+  });
+
+  observe_DependencyManager(metamodel.dependencyManager);
+
+  return metamodel;
+};