@finos/legend-graph 2.1.3 → 3.0.0

package/src/models/metamodels/pure/packageableElements/PackageableElement.ts

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import { observable, action, computed, makeObservable } from 'mobx';
 import {
   type Hashable,
   hashArray,
@@ -67,42 +66,20 @@ export interface PackageableElementVisitor<T> {
   visit_GenerationSpecification(element: GenerationSpecification): T;
 }
 
-export abstract class PackageableElement implements Hashable, Stubable {
-  uuid = uuid();
+export abstract class /*toCHECK*/ PackageableElement
+  implements Hashable, Stubable
+{
+  readonly uuid = uuid();
+
   protected _isDeleted = false;
   protected _isDisposed = false;
-  protected _isImmutable = false;
   name: string;
   package?: Package | undefined;
 
   constructor(name: string) {
-    makeObservable<
-      PackageableElement,
-      '_isDeleted' | '_isDisposed' | '_isImmutable' | '_elementHashCode'
-    >(this, {
-      _isDeleted: observable,
-      _isDisposed: observable,
-      _isImmutable: observable,
-      name: observable,
-      package: observable,
-      isReadOnly: computed,
-      isDeleted: computed,
-      path: computed,
-      _elementHashCode: computed,
-      // We need to enable `keepAlive` to facillitate precomputation of element hash code
-      hashCode: computed({ keepAlive: true }),
-      setIsDeleted: action,
-      dispose: action,
-      freeze: action,
-    });
-
     this.name = name;
   }
 
-  get isReadOnly(): boolean {
-    return this._isImmutable;
-  }
-
   get isDeleted(): boolean {
     return this._isDeleted;
   }
@@ -112,6 +89,7 @@ export abstract class PackageableElement implements Hashable, Stubable {
   }
 
   /**
+   * TODO: move this out to `DomainHelper` and make this method return `Package` instead of `PackageableElement`.
    * Get root element. In the ideal case, this method is important for finding the root package, but
    * if we do something like `this instanceof Package` that would case circular dependency.
    */
@@ -129,31 +107,28 @@ export abstract class PackageableElement implements Hashable, Stubable {
       : `${parentPackageName}${ELEMENT_PATH_DELIMITER}${this.name}`;
   }
 
-  // NOTE: we don't need `createStub` as the subclasses will have to implement their own for type narrowing
   get isStub(): boolean {
     return !this.name && !this.package;
   }
 
   /**
-   * Since `keepAlive` can cause memory-leak, we need to dispose it manually when we are about to discard the graph
-   * in order to avoid leaking.
-   * See https://mobx.js.org/best/pitfalls.html#computed-values-run-more-often-than-expected
-   * See https://medium.com/terria/when-and-why-does-mobxs-keepalive-cause-a-memory-leak-8c29feb9ff55
+   * Dispose the element and its references to avoid memory leaks
    */
   dispose(): void {
     this._isDisposed = true;
-    // trigger recomputation on `hashCode` so it removes itself from all observables it previously observed
-    try {
-      this.hashCode;
-    } catch {
-      /* do nothing */
-    }
-  }
-
-  freeze(): void {
-    this._isImmutable = true;
-    // Since hash code computation depends on this flag, we retrigger and wrap in a try catch to prevent future call
-    // to get `hashCode`, as this would indicate mutation
+    /**
+     * Trigger recomputation on `hashCode` so if the element is observed, hash code computation will now
+     * remove itself from all observables it previously observed
+     *
+     * NOTE: we used to do this since we decorate `hashCode` with `computed({ keepAlive: true })` which
+     * poses a memory-leak threat
+     *
+     * See https://mobx.js.org/computeds.html#keepalive
+     *
+     * However, since we're calling `keepAlive` actively now and dispose it right away to return `hashCode` to
+     * a normal computed value, we might not need this step anymore. But we're being extremely defensive here
+     * to avoid memory leak.
+     */
     try {
       this.hashCode;
     } catch {
@@ -169,22 +144,7 @@ export abstract class PackageableElement implements Hashable, Stubable {
     if (this._isDisposed) {
       throw new IllegalStateError(`Element '${this.path}' is already disposed`);
     }
-    // If this computation is placed after checking for immutability flag,
-    // error will be thrown and therefore, `mobx` will not recompute this at all.
-    // By putting this here, we make sure that even when the element is frozen,
-    // if somehow the element modified, computation of the hash code will be triggered.
-    // As a result, error will be thrown again. This is a good way to notify developer
-    // that the object has been modified, this is a better alternative to than using
-    // `Object.freeze`, which requires a more complicated setup.
-    // Also, using `Object.freeze` does not really solve the problem
-    // See https://github.com/mobxjs/mobx/issues/3008
-    const hashCode = this._elementHashCode;
-    if (this._isImmutable) {
-      throw new IllegalStateError(
-        `Readonly element '${this.path}' is modified`,
-      );
-    }
-    return hashCode;
+    return this._elementHashCode;
   }
 
   abstract accept_PackageableElementVisitor<T>(

package/src/models/metamodels/pure/packageableElements/PackageableElementReference.ts

@@ -15,7 +15,6 @@
  */
 
 import { assertType } from '@finos/legend-shared';
-import { observable, action, computed, makeObservable } from 'mobx';
 import type { PackageableElement } from './PackageableElement';
 import type { Section } from './section/Section';
 import { RequiredReference, OptionalReference } from '../Reference';
@@ -27,11 +26,6 @@ export abstract class PackageableElementReference<
 
   protected constructor(value: T) {
     super();
-
-    makeObservable(this, {
-      value: observable,
-    });
-
     this.value = value;
   }
 
@@ -47,10 +41,6 @@ export class PackageableElementExplicitReference<
 > extends PackageableElementReference<T> {
   private constructor(value: T) {
     super(value);
-
-    makeObservable(this, {
-      valueForSerialization: computed,
-    });
   }
 
   static create<V extends PackageableElement>(
@@ -100,10 +90,6 @@ export class PackageableElementImplicitReference<
   ) {
     super(value);
 
-    makeObservable(this, {
-      valueForSerialization: computed,
-    });
-
     this.initialResolvedPath = value.path;
     this.input = input;
     this.parentSection = parentSection;
@@ -167,16 +153,6 @@ export abstract class OptionalPackageableElementReference<
 
   protected constructor(value: T | undefined) {
     super();
-
-    makeObservable(this, {
-      value: observable,
-      setValue: action,
-    });
-
-    this.value = value;
-  }
-
-  setValue(value: T | undefined): void {
     this.value = value;
   }
 
@@ -188,10 +164,6 @@ export class OptionalPackageableElementExplicitReference<
 > extends OptionalPackageableElementReference<T> {
   private constructor(value: T | undefined) {
     super(value);
-
-    makeObservable(this, {
-      valueForSerialization: computed,
-    });
   }
 
   static create<V extends PackageableElement>(
@@ -220,11 +192,6 @@ export class OptionalPackageableElementImplicitReference<
     skipSectionCheck: boolean | undefined,
   ) {
     super(value);
-
-    makeObservable(this, {
-      valueForSerialization: computed,
-    });
-
     this.initialResolvedPath = value?.path;
     this.input = input;
     this.parentSection = parentSection;

package/src/models/metamodels/pure/packageableElements/connection/Connection.ts

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import { computed, makeObservable, observable } from 'mobx';
 import { hashArray, uuid, type Hashable } from '@finos/legend-shared';
 import { CORE_HASH_STRUCTURE } from '../../../../../MetaModelConst';
 import type { Store } from '../store/Store';
@@ -39,16 +38,13 @@ export interface ConnectionVisitor<T> {
 }
 
 export abstract class Connection implements Hashable {
-  uuid = uuid();
+  readonly uuid = uuid();
+
   // in Pure right now, this is of type Any[1], but technically it should be a store
   store: PackageableElementReference<Store>;
 
   constructor(store: PackageableElementReference<Store>) {
     this.store = store;
-
-    makeObservable(this, {
-      store: observable,
-    });
   }
 
   abstract get hashCode(): string;
@@ -63,18 +59,9 @@ export class ConnectionPointer extends Connection implements Hashable {
     packageableConnection: PackageableElementReference<PackageableConnection>,
   ) {
     super(packageableConnection.value.connectionValue.store);
-
-    makeObservable(this, {
-      hashCode: computed,
-    });
-
     this.packageableConnection = packageableConnection;
   }
 
-  setPackageableConnection(value: PackageableConnection): void {
-    this.packageableConnection.value = value;
-  }
-
   get hashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.CONNECTION_POINTER,

package/src/models/metamodels/pure/packageableElements/connection/PackageableConnection.ts

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import { observable, makeObservable, override } from 'mobx';
 import { hashArray, type Hashable } from '@finos/legend-shared';
 import { CORE_HASH_STRUCTURE } from '../../../../../MetaModelConst';
 import {
@@ -29,15 +28,6 @@ export class PackageableConnection
 {
   connectionValue!: Connection;
 
-  constructor(name: string) {
-    super(name);
-
-    makeObservable<PackageableConnection, '_elementHashCode'>(this, {
-      connectionValue: observable,
-      _elementHashCode: override,
-    });
-  }
-
   protected override get _elementHashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.PACKAGEABLE_CONNECTION,

package/src/models/metamodels/pure/packageableElements/domain/Association.ts

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import { observable, computed, makeObservable, override } from 'mobx';
 import {
   type Hashable,
   guaranteeNonNullable,
@@ -22,8 +21,6 @@ import {
   assertTrue,
   UnsupportedOperationError,
   hashArray,
-  addUniqueEntry,
-  deleteEntry,
 } from '@finos/legend-shared';
 import { CORE_HASH_STRUCTURE } from '../../../../../MetaModelConst';
 import {
@@ -32,7 +29,6 @@ import {
 } from '../PackageableElement';
 import { Property } from './Property';
 import { type Stubable, isStubArray } from '../../../../../helpers/Stubable';
-import { GenericType } from './GenericType';
 import { Class } from './Class';
 import type { AnnotatedElement } from './AnnotatedElement';
 import type { TaggedValue } from './TaggedValue';
@@ -78,19 +74,6 @@ export class Association
   taggedValues: TaggedValue[] = [];
   derivedProperties: DerivedProperty[] = [];
 
-  constructor(name: string) {
-    super(name);
-
-    makeObservable<Association, '_elementHashCode'>(this, {
-      properties: observable,
-      stereotypes: observable,
-      taggedValues: observable,
-      derivedProperties: observable,
-      isStub: computed,
-      _elementHashCode: override,
-    });
-  }
-
   getFirstProperty = (): Property => guaranteeNonNullable(this.properties[0]);
   getSecondProperty = (): Property => guaranteeNonNullable(this.properties[1]);
   getOtherProperty = (property: Property): Property => {
@@ -125,32 +108,6 @@ export class Association
       `Can't find property '${name}' in class '${this.path}'`,
     );
 
-  changePropertyType = (property: Property, type: Class): void => {
-    const otherProperty = this.getOtherProperty(property);
-    // remove other property from current parent class of the to-be-changed property
-    const otherPropertyAssociatedClass = guaranteeType(
-      property.genericType.ownerReference.value,
-      Class,
-      `Association property '${property.name}' must be of type 'class'`,
-    );
-    // don't invoke deletion if the class is a stub (otherProperty is not present)
-    if (!otherPropertyAssociatedClass.isStub) {
-      assertTrue(
-        deleteEntry(
-          otherPropertyAssociatedClass.propertiesFromAssociations,
-          otherProperty,
-        ),
-        `Can't find property '${otherProperty.name}' from association '${this.path}' in associated class '${otherPropertyAssociatedClass.path}'`,
-      );
-    }
-    // set up the relationship between the other property and the new class
-    addUniqueEntry(type.propertiesFromAssociations, otherProperty);
-    // set new type for the property
-    const _genType = new GenericType(type);
-    property.genericType.value = _genType;
-    property.genericType.ownerReference.value = _genType.rawType;
-  };
-
   override get isStub(): boolean {
     return super.isStub && isStubArray(this.properties);
   }

package/src/models/metamodels/pure/packageableElements/domain/Class.ts

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import { observable, computed, makeObservable, override } from 'mobx';
 import {
   type Hashable,
   hashArray,
@@ -59,26 +58,6 @@ export class Class extends Type implements Hashable, Stubable {
   stereotypes: StereotypeReference[] = [];
   taggedValues: TaggedValue[] = [];
 
-  constructor(name: string) {
-    super(name);
-
-    makeObservable<Class, '_elementHashCode'>(this, {
-      properties: observable,
-      propertiesFromAssociations: observable,
-      derivedProperties: observable,
-      generalizations: observable,
-      subclasses: observable,
-      constraints: observable,
-      stereotypes: observable,
-      taggedValues: observable,
-      allSuperclasses: computed,
-      allSubclasses: computed({ keepAlive: true }),
-      dispose: override,
-      isStub: computed,
-      _elementHashCode: override,
-    });
-  }
-
   /**
    * Get class and its supertypes' properties recursively, duplications and loops are handled (Which should be caught by compiler)
    */
@@ -192,21 +171,13 @@ export class Class extends Type implements Hashable, Stubable {
   }
 
   /**
-   * @MARKER MEMORY-SENSITIVE
-   * Since `keepAlive` can cause memory-leak, we need to dispose it manually when we are about to discard the graph
-   * in order to avoid leaking.
-   * See https://mobx.js.org/best/pitfalls.html#computed-values-run-more-often-than-expected
-   * See https://medium.com/terria/when-and-why-does-mobxs-keepalive-cause-a-memory-leak-8c29feb9ff55
+   * Make sure to remove the disposed class from being referenced in other elements
+   * e.g. subclass analytics is great, but it causes the class being referred to by classes
+   * coming from system or dependencies
    */
   override dispose(): void {
+    super.dispose();
     this.subclasses = []; // call this before setting `disposed` flag to avoid triggering errors if something is using this during disposal
-    this._isDisposed = true;
-    // dispose hash computation
-    try {
-      this.hashCode;
-    } catch {
-      /* do nothing */
-    } // trigger recomputation on `hashCode` so it removes itself from all observables it previously observed
     // cleanup subclasses analytics on superclasses
     this.allSuperclasses.forEach((superclass) => {
       if (!superclass._isDisposed) {

package/src/models/metamodels/pure/packageableElements/domain/ConcreteFunctionDefinition.ts

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import { observable, makeObservable, override } from 'mobx';
 import { type Hashable, hashArray } from '@finos/legend-shared';
 import { hashLambda } from '../../../../../MetaModelUtils';
 import { CORE_HASH_STRUCTURE } from '../../../../../MetaModelConst';
@@ -45,16 +44,6 @@ export class ConcreteFunctionDefinition
     returnMultiplicity: Multiplicity,
   ) {
     super(name);
-
-    makeObservable<ConcreteFunctionDefinition, '_elementHashCode'>(this, {
-      returnMultiplicity: observable,
-      parameters: observable.shallow,
-      body: observable.ref,
-      stereotypes: observable,
-      taggedValues: observable,
-      _elementHashCode: override,
-    });
-
     this.returnType = returnType;
     this.returnMultiplicity = returnMultiplicity;
   }

package/src/models/metamodels/pure/packageableElements/domain/Constraint.ts

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import { observable, computed, makeObservable } from 'mobx';
 import { CORE_HASH_STRUCTURE } from '../../../../../MetaModelConst';
 import { hashArray, uuid, type Hashable } from '@finos/legend-shared';
 import { RawLambda } from '../../rawValueSpecification/RawLambda';
@@ -22,25 +21,16 @@ import type { Class } from './Class';
 import type { Stubable } from '../../../../../helpers/Stubable';
 
 export class Constraint implements Hashable, Stubable {
-  uuid = uuid();
-  name: string;
+  readonly uuid = uuid();
   owner: Class;
+
+  name: string;
   functionDefinition: RawLambda; // @MARKER GENERATED MODEL DISCREPANCY --- Studio does not process lambda
   externalId?: string | undefined;
   enforcementLevel?: string | undefined;
   messageFunction?: RawLambda | undefined; // @MARKER GENERATED MODEL DISCREPANCY --- Studio does not process lambda
 
   constructor(name: string, owner: Class, functionDefinition: RawLambda) {
-    makeObservable(this, {
-      name: observable,
-      functionDefinition: observable,
-      externalId: observable,
-      enforcementLevel: observable,
-      messageFunction: observable,
-      isStub: computed,
-      hashCode: computed,
-    });
-
     this.name = name;
     this.owner = owner;
     this.functionDefinition = functionDefinition;

package/src/models/metamodels/pure/packageableElements/domain/DerivedProperty.ts

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import { observable, computed, makeObservable } from 'mobx';
 import { type Hashable, hashArray, uuid } from '@finos/legend-shared';
 import { hashLambda } from '../../../../../MetaModelUtils';
 import { CORE_HASH_STRUCTURE } from '../../../../../MetaModelConst';
@@ -35,8 +34,9 @@ import {
 export class DerivedProperty
   implements AbstractProperty, AnnotatedElement, Hashable, Stubable
 {
-  uuid = uuid();
+  readonly uuid = uuid();
   owner: PropertyOwner; // readonly
+
   name: string;
   genericType: GenericTypeReference;
   multiplicity: Multiplicity;
@@ -51,17 +51,6 @@ export class DerivedProperty
     genericType: GenericTypeReference,
     owner: PropertyOwner,
   ) {
-    makeObservable(this, {
-      name: observable,
-      multiplicity: observable,
-      stereotypes: observable,
-      taggedValues: observable,
-      body: observable.ref,
-      parameters: observable.ref,
-      isStub: computed,
-      hashCode: computed,
-    });
-
     this.name = name;
     this.multiplicity = multiplicity;
     this.genericType = genericType;

package/src/models/metamodels/pure/packageableElements/domain/Enum.ts

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import { observable, computed, makeObservable } from 'mobx';
 import { type Hashable, uuid, hashArray } from '@finos/legend-shared';
 import { CORE_HASH_STRUCTURE } from '../../../../../MetaModelConst';
 import type { Enumeration } from './Enumeration';
@@ -24,21 +23,14 @@ import type { Stubable } from '../../../../../helpers/Stubable';
 import type { StereotypeReference } from './StereotypeReference';
 
 export class Enum implements AnnotatedElement, Hashable, Stubable {
-  uuid = uuid();
+  readonly uuid = uuid();
   owner: Enumeration;
+
   name: string;
   stereotypes: StereotypeReference[] = [];
   taggedValues: TaggedValue[] = [];
 
   constructor(name: string, owner: Enumeration) {
-    makeObservable(this, {
-      name: observable,
-      stereotypes: observable,
-      taggedValues: observable,
-      isStub: computed,
-      hashCode: computed,
-    });
-
     this.name = name;
     this.owner = owner;
   }

package/src/models/metamodels/pure/packageableElements/domain/EnumValueReference.ts

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import { observable, computed, makeObservable } from 'mobx';
 import {
   PackageableElementExplicitReference,
   type PackageableElementReference,
@@ -37,12 +36,6 @@ export abstract class EnumValueReference
     value: Enum,
   ) {
     super(ownerReference);
-
-    makeObservable(this, {
-      value: observable,
-      isStub: computed,
-    });
-
     this.ownerReference = ownerReference;
     this.value = value;
   }

package/src/models/metamodels/pure/packageableElements/domain/Enumeration.ts

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import { observable, computed, makeObservable, override } from 'mobx';
 import {
   type Hashable,
   hashArray,
@@ -34,18 +33,6 @@ export class Enumeration extends DataType implements Hashable, Stubable {
   stereotypes: StereotypeReference[] = [];
   taggedValues: TaggedValue[] = [];
 
-  constructor(name: string) {
-    super(name);
-
-    makeObservable<Enumeration, '_elementHashCode'>(this, {
-      values: observable,
-      stereotypes: observable,
-      taggedValues: observable,
-      isStub: computed,
-      _elementHashCode: override,
-    });
-  }
-
   getValueNames = (): string[] =>
     this.values.map((value) => value.name).filter(Boolean);
   getValue = (name: string): Enum =>

package/src/models/metamodels/pure/packageableElements/domain/GenericType.ts

@@ -14,21 +14,15 @@
  * limitations under the License.
  */
 
-import { observable, computed, makeObservable } from 'mobx';
 import { type Clazz, guaranteeType, uuid } from '@finos/legend-shared';
 import type { Type } from './Type';
 import type { Stubable } from '../../../../../helpers/Stubable';
 
 export class GenericType implements Stubable {
-  uuid = uuid();
+  readonly uuid = uuid();
   rawType: Type;
 
   constructor(rawType: Type) {
-    makeObservable(this, {
-      rawType: observable,
-      isStub: computed,
-    });
-
     this.rawType = rawType;
   }
 

package/src/models/metamodels/pure/packageableElements/domain/GenericTypeReference.ts

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import { observable, computed, makeObservable } from 'mobx';
 import {
   PackageableElementExplicitReference,
   type PackageableElementReference,
@@ -38,11 +37,6 @@ export abstract class GenericTypeReference
   ) {
     super(ownerReference);
 
-    makeObservable(this, {
-      value: observable,
-      isStub: computed,
-    });
-
     this.ownerReference = ownerReference;
     this.value = value;
   }

package/src/models/metamodels/pure/packageableElements/domain/Measure.ts

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import { observable, makeObservable, override } from 'mobx';
 import {
   hashArray,
   UnsupportedOperationError,
@@ -37,12 +36,6 @@ export class Unit extends DataType implements Hashable {
   ) {
     super(name);
 
-    makeObservable(this, {
-      measure: observable,
-      conversionFunction: observable,
-      hashCode: override,
-    });
-
     this.measure = measure;
     this.conversionFunction = conversionFunction;
   }
@@ -73,16 +66,6 @@ export class Measure extends Type implements Hashable {
   canonicalUnit?: Unit | undefined;
   nonCanonicalUnits: Unit[] = [];
 
-  constructor(name: string) {
-    super(name);
-
-    makeObservable<Measure, '_elementHashCode'>(this, {
-      canonicalUnit: observable,
-      nonCanonicalUnits: observable,
-      _elementHashCode: override,
-    });
-  }
-
   isSubType(type: Type): boolean {
     return false;
   }