@finos/legend-graph 5.0.0 → 7.0.0

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

@@ -16,34 +16,35 @@
 
 import { CORE_HASH_STRUCTURE } from '../../../../../MetaModelConst';
 import { hashArray, uuid, type Hashable } from '@finos/legend-shared';
-import { RawLambda } from '../../rawValueSpecification/RawLambda';
+import type { RawLambda } from '../../rawValueSpecification/RawLambda';
 import type { Class } from './Class';
-import type { Stubable } from '../../../../../helpers/Stubable';
 
-export class Constraint implements Hashable, Stubable {
-  readonly uuid = uuid();
-  owner: Class;
+export class Constraint implements Hashable {
+  readonly _UUID = uuid();
+  readonly _OWNER: Class;
 
   name: string;
-  functionDefinition: RawLambda; // @MARKER GENERATED MODEL DISCREPANCY --- Studio does not process lambda
+  /**
+   * Studio does not process value specification, they are left in raw JSON form
+   *
+   * @discrepancy model
+   */
+  functionDefinition: RawLambda;
   externalId?: string | undefined;
   enforcementLevel?: string | undefined;
-  messageFunction?: RawLambda | undefined; // @MARKER GENERATED MODEL DISCREPANCY --- Studio does not process lambda
+  /**
+   * Studio does not process value specification, they are left in raw JSON form
+   *
+   * @discrepancy model
+   */
+  messageFunction?: RawLambda | undefined;
 
   constructor(name: string, owner: Class, functionDefinition: RawLambda) {
     this.name = name;
-    this.owner = owner;
+    this._OWNER = owner;
     this.functionDefinition = functionDefinition;
   }
 
-  static createStub = (_class: Class): Constraint =>
-    new Constraint('', _class, RawLambda.createStub());
-  // the constraint is considered stub if it doesn't have a body in the function definition lambda because
-  // without the function definition, it is not even parsable and so we should not transform this
-  get isStub(): boolean {
-    return !this.functionDefinition.body;
-  }
-
   get hashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.CONSTRAINT,

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

@@ -17,33 +17,36 @@
 import { type Hashable, hashArray, uuid } from '@finos/legend-shared';
 import { hashLambda } from '../../../../../MetaModelUtils';
 import { CORE_HASH_STRUCTURE } from '../../../../../MetaModelConst';
-import { Multiplicity } from './Multiplicity';
+import type { Multiplicity } from './Multiplicity';
 import type { TaggedValue } from './TaggedValue';
 import type { AbstractProperty, PropertyOwner } from './AbstractProperty';
 import type { AnnotatedElement } from './AnnotatedElement';
-import { GenericType } from './GenericType';
-import type { Class } from './Class';
-import type { Type } from './Type';
-import type { Stubable } from '../../../../../helpers/Stubable';
 import type { StereotypeReference } from './StereotypeReference';
-import {
-  type GenericTypeReference,
-  GenericTypeExplicitReference,
-} from './GenericTypeReference';
+import type { GenericTypeReference } from './GenericTypeReference';
 
 export class DerivedProperty
-  implements AbstractProperty, AnnotatedElement, Hashable, Stubable
+  implements AbstractProperty, AnnotatedElement, Hashable
 {
-  readonly uuid = uuid();
-  owner: PropertyOwner; // readonly
+  readonly _UUID = uuid();
+  readonly _OWNER: PropertyOwner;
 
   name: string;
   genericType: GenericTypeReference;
   multiplicity: Multiplicity;
   stereotypes: StereotypeReference[] = [];
   taggedValues: TaggedValue[] = [];
-  body?: object | undefined; // @MARKER GENERATED MODEL DISCREPANCY --- Studio does not process lambda
-  parameters?: object | undefined; // @MARKER GENERATED MODEL DISCREPANCY --- Studio does not process lambda
+  /**
+   * Studio does not process value specification, they are left in raw JSON form
+   *
+   * @discrepancy model
+   */
+  body?: object | undefined;
+  /**
+   * Studio does not process value specification, they are left in raw JSON form
+   *
+   * @discrepancy model
+   */
+  parameters?: object | undefined;
 
   constructor(
     name: string,
@@ -54,18 +57,7 @@ export class DerivedProperty
     this.name = name;
     this.multiplicity = multiplicity;
     this.genericType = genericType;
-    this.owner = owner;
-  }
-  static createStub = (type: Type, _class: Class): DerivedProperty =>
-    new DerivedProperty(
-      '',
-      new Multiplicity(1, 1),
-      GenericTypeExplicitReference.create(new GenericType(type)),
-      _class,
-    );
-  // the derived property is considered stub if it doesn't have a body in the lambda because without a body, it is not parsable, and should be discarded in transformer
-  get isStub(): boolean {
-    return !this.body;
+    this._OWNER = owner;
   }
 
   get hashCode(): string {

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

@@ -19,12 +19,11 @@ import { CORE_HASH_STRUCTURE } from '../../../../../MetaModelConst';
 import type { Enumeration } from './Enumeration';
 import type { TaggedValue } from './TaggedValue';
 import type { AnnotatedElement } from './AnnotatedElement';
-import type { Stubable } from '../../../../../helpers/Stubable';
 import type { StereotypeReference } from './StereotypeReference';
 
-export class Enum implements AnnotatedElement, Hashable, Stubable {
-  readonly uuid = uuid();
-  owner: Enumeration;
+export class Enum implements AnnotatedElement, Hashable {
+  readonly _UUID = uuid();
+  readonly _OWNER: Enumeration;
 
   name: string;
   stereotypes: StereotypeReference[] = [];
@@ -32,13 +31,7 @@ export class Enum implements AnnotatedElement, Hashable, Stubable {
 
   constructor(name: string, owner: Enumeration) {
     this.name = name;
-    this.owner = owner;
-  }
-
-  static createStub = (parentEnumeration: Enumeration): Enum =>
-    new Enum('', parentEnumeration);
-  get isStub(): boolean {
-    return !this.name;
+    this._OWNER = owner;
   }
 
   get hashCode(): string {

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

@@ -21,13 +21,9 @@ import {
 } from '../PackageableElementReference';
 import type { Enumeration } from './Enumeration';
 import type { Enum } from './Enum';
-import type { Stubable } from '../../../../../helpers/Stubable';
 import { ReferenceWithOwner } from '../../Reference';
 
-export abstract class EnumValueReference
-  extends ReferenceWithOwner
-  implements Stubable
-{
+export abstract class EnumValueReference extends ReferenceWithOwner {
   override readonly ownerReference: PackageableElementReference<Enumeration>;
   value: Enum;
 
@@ -39,10 +35,6 @@ export abstract class EnumValueReference
     this.ownerReference = ownerReference;
     this.value = value;
   }
-
-  get isStub(): boolean {
-    return !this.value.isStub;
-  }
 }
 
 export class EnumValueExplicitReference extends EnumValueReference {
@@ -50,7 +42,7 @@ export class EnumValueExplicitReference extends EnumValueReference {
 
   private constructor(value: Enum) {
     const ownerReference = PackageableElementExplicitReference.create(
-      value.owner,
+      value._OWNER,
     );
     super(ownerReference, value);
     this.ownerReference = ownerReference;

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

@@ -14,46 +14,19 @@
  * limitations under the License.
  */
 
-import {
-  type Hashable,
-  hashArray,
-  guaranteeNonNullable,
-} from '@finos/legend-shared';
+import { type Hashable, hashArray } from '@finos/legend-shared';
 import { CORE_HASH_STRUCTURE } from '../../../../../MetaModelConst';
 import { DataType } from './DataType';
 import type { Enum } from './Enum';
-import { type Stubable, isStubArray } from '../../../../../helpers/Stubable';
 import type { PackageableElementVisitor } from '../PackageableElement';
-import type { Type } from './Type';
 import type { StereotypeReference } from './StereotypeReference';
 import type { TaggedValue } from './TaggedValue';
 
-export class Enumeration extends DataType implements Hashable, Stubable {
+export class Enumeration extends DataType implements Hashable {
   values: Enum[] = [];
   stereotypes: StereotypeReference[] = [];
   taggedValues: TaggedValue[] = [];
 
-  getValueNames = (): string[] =>
-    this.values.map((value) => value.name).filter(Boolean);
-  getValue = (name: string): Enum =>
-    guaranteeNonNullable(
-      this.values.find((value) => value.name === name),
-      `Can't find enum value '${name}' in enumeration '${this.path}'`,
-    );
-  static createStub = (): Enumeration => new Enumeration('');
-
-  override get isStub(): boolean {
-    return super.isStub && isStubArray(this.values);
-  }
-
-  isSuperType(type: Type): boolean {
-    return false;
-  }
-
-  isSubType(type: Type): boolean {
-    return false;
-  }
-
   protected override get _elementHashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.ENUMERATION,

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

@@ -14,24 +14,15 @@
  * limitations under the License.
  */
 
-import { type Clazz, guaranteeType, uuid } from '@finos/legend-shared';
+import { uuid } from '@finos/legend-shared';
 import type { Type } from './Type';
-import type { Stubable } from '../../../../../helpers/Stubable';
 
-export class GenericType implements Stubable {
-  readonly uuid = uuid();
+export class GenericType {
+  readonly _UUID = uuid();
+
   rawType: Type;
 
   constructor(rawType: Type) {
     this.rawType = rawType;
   }
-
-  getRawType = <T extends Type>(clazz: Clazz<T>): T =>
-    guaranteeType<T>(this.rawType, clazz);
-
-  // NOTE: we don't have a `createStub` for GenericType because it all depends on the type passed in
-  // so might as well use constructor
-  get isStub(): boolean {
-    return this.rawType.isStub;
-  }
 }

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

@@ -19,15 +19,11 @@ import {
   type PackageableElementReference,
   type PackageableElementImplicitReference,
 } from '../PackageableElementReference';
-import type { Stubable } from '../../../../../helpers/Stubable';
 import { ReferenceWithOwner } from '../../Reference';
 import type { GenericType } from './GenericType';
 import type { Type } from './Type';
 
-export abstract class GenericTypeReference
-  extends ReferenceWithOwner
-  implements Stubable
-{
+export abstract class GenericTypeReference extends ReferenceWithOwner {
   override readonly ownerReference: PackageableElementReference<Type>;
   value: GenericType;
 
@@ -40,10 +36,6 @@ export abstract class GenericTypeReference
     this.ownerReference = ownerReference;
     this.value = value;
   }
-
-  get isStub(): boolean {
-    return !this.value.isStub;
-  }
 }
 
 export class GenericTypeExplicitReference extends GenericTypeReference {

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

@@ -27,7 +27,12 @@ import type { RawLambda } from '../../rawValueSpecification/RawLambda';
 
 export class Unit extends DataType implements Hashable {
   measure: Measure;
-  conversionFunction?: RawLambda | undefined; // @MARKER GENERATED MODEL DISCREPANCY --- Studio does not process lambda
+  /**
+   * Studio does not process value specification, they are left in raw JSON form
+   *
+   * @discrepancy model
+   */
+  conversionFunction?: RawLambda | undefined;
 
   constructor(
     name: string,
@@ -40,13 +45,6 @@ export class Unit extends DataType implements Hashable {
     this.conversionFunction = conversionFunction;
   }
 
-  isSuperType(type: Type): boolean {
-    return false;
-  }
-  isSubType(type: Type): boolean {
-    return this.measure === type;
-  }
-
   override get hashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.UNIT,
@@ -66,14 +64,6 @@ export class Measure extends Type implements Hashable {
   canonicalUnit?: Unit | undefined;
   nonCanonicalUnits: Unit[] = [];
 
-  isSubType(type: Type): boolean {
-    return false;
-  }
-
-  isSuperType(type: Type): boolean {
-    return type instanceof Unit && type.measure === this;
-  }
-
   protected override get _elementHashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.MEASURE,

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

@@ -14,10 +14,7 @@
  * limitations under the License.
  */
 
-import {
-  CORE_HASH_STRUCTURE,
-  MULTIPLICITY_INFINITE,
-} from '../../../../../MetaModelConst';
+import { CORE_HASH_STRUCTURE } from '../../../../../MetaModelConst';
 import { hashArray, type Hashable } from '@finos/legend-shared';
 
 export class Multiplicity implements Hashable {
@@ -29,16 +26,11 @@ export class Multiplicity implements Hashable {
     this.upperBound = upperBound;
   }
 
-  get str(): string {
-    if (this.lowerBound === this.upperBound) {
-      return this.lowerBound.toString();
-    } else if (this.lowerBound === 0 && this.upperBound === undefined) {
-      return MULTIPLICITY_INFINITE;
-    }
-    return `${this.lowerBound}..${this.upperBound ?? MULTIPLICITY_INFINITE}`;
-  }
-
   get hashCode(): string {
-    return hashArray([CORE_HASH_STRUCTURE.MULTIPLICITY, this.str]);
+    return hashArray([
+      CORE_HASH_STRUCTURE.MULTIPLICITY,
+      this.lowerBound.toString(),
+      this.upperBound?.toString() ?? '',
+    ]);
   }
 }

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

@@ -14,11 +14,7 @@
  * limitations under the License.
  */
 
-import {
-  CORE_HASH_STRUCTURE,
-  ELEMENT_PATH_DELIMITER,
-} from '../../../../../MetaModelConst';
-import { type Hashable, hashArray } from '@finos/legend-shared';
+import type { Hashable } from '@finos/legend-shared';
 import {
   type PackageableElementVisitor,
   PackageableElement,
@@ -27,22 +23,19 @@ import {
 export class Package extends PackageableElement implements Hashable {
   children: PackageableElement[] = [];
 
-  get fullPath(): string {
-    if (!this.package) {
-      return '';
-    }
-    const parentPackageName = this.package.fullPath;
-    return !parentPackageName
-      ? this.name
-      : `${parentPackageName}${ELEMENT_PATH_DELIMITER}${this.name}`;
+  /**
+   * This logic is specific to the codebase and this is not part of the native metamodel.
+   * If needed, we can probably move this out as an utility or do type declaration merge
+   * and define this externally using `Object.defineProperty`.
+   *
+   * @internal model logic
+   */
+  override get path(): string {
+    return !this.package ? '' : super.path;
   }
 
   override get hashCode(): string {
-    return hashArray([
-      CORE_HASH_STRUCTURE.PACKAGE,
-      this.path,
-      hashArray(this.children.map((child) => child.path)),
-    ]);
+    return '';
   }
 
   accept_PackageableElementVisitor<T>(

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

@@ -14,54 +14,10 @@
  * limitations under the License.
  */
 
-import { PRIMITIVE_TYPE } from '../../../../../MetaModelConst';
 import { DataType } from './DataType';
 import type { PackageableElementVisitor } from '../PackageableElement';
-import type { Type } from './Type';
 
 export class PrimitiveType extends DataType {
-  isSuperType(type: Type): boolean {
-    if (!(type instanceof PrimitiveType)) {
-      return false;
-    }
-    if (this.name === PRIMITIVE_TYPE.NUMBER) {
-      return (
-        type.name === PRIMITIVE_TYPE.INTEGER ||
-        type.name === PRIMITIVE_TYPE.FLOAT ||
-        type.name === PRIMITIVE_TYPE.DECIMAL
-      );
-    }
-    if (this.name === PRIMITIVE_TYPE.DATE) {
-      return (
-        type.name === PRIMITIVE_TYPE.STRICTDATE ||
-        type.name === PRIMITIVE_TYPE.DATETIME ||
-        type.name === PRIMITIVE_TYPE.LATESTDATE
-      );
-    }
-    return false;
-  }
-
-  isSubType(type: Type): boolean {
-    if (!(type instanceof PrimitiveType)) {
-      return false;
-    }
-    if (type.name === PRIMITIVE_TYPE.NUMBER) {
-      return (
-        this.name === PRIMITIVE_TYPE.INTEGER ||
-        this.name === PRIMITIVE_TYPE.FLOAT ||
-        this.name === PRIMITIVE_TYPE.DECIMAL
-      );
-    }
-    if (type.name === PRIMITIVE_TYPE.DATE) {
-      return (
-        this.name === PRIMITIVE_TYPE.STRICTDATE ||
-        this.name === PRIMITIVE_TYPE.DATETIME ||
-        this.name === PRIMITIVE_TYPE.LATESTDATE
-      );
-    }
-    return false;
-  }
-
   accept_PackageableElementVisitor<T>(
     visitor: PackageableElementVisitor<T>,
   ): T {

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

@@ -14,11 +14,7 @@
  * limitations under the License.
  */
 
-import {
-  type Hashable,
-  guaranteeNonNullable,
-  hashArray,
-} from '@finos/legend-shared';
+import { type Hashable, hashArray } from '@finos/legend-shared';
 import { CORE_HASH_STRUCTURE } from '../../../../../MetaModelConst';
 import {
   type PackageableElementVisitor,
@@ -26,31 +22,11 @@ import {
 } from '../PackageableElement';
 import type { Stereotype } from './Stereotype';
 import type { Tag } from './Tag';
-import { type Stubable, isStubArray } from '../../../../../helpers/Stubable';
 
-export class Profile extends PackageableElement implements Hashable, Stubable {
+export class Profile extends PackageableElement implements Hashable {
   stereotypes: Stereotype[] = [];
   tags: Tag[] = [];
 
-  getTag = (value: string): Tag =>
-    guaranteeNonNullable(
-      this.tags.find((tag) => tag.value === value),
-      `Can't find tag '${value}' in profile '${this.path}'`,
-    );
-
-  getStereotype = (value: string): Stereotype =>
-    guaranteeNonNullable(
-      this.stereotypes.find((stereotype) => stereotype.value === value),
-      `Can't find stereotype '${value}' in profile '${this.path}'`,
-    );
-
-  static createStub = (): Profile => new Profile('');
-  override get isStub(): boolean {
-    return (
-      super.isStub && isStubArray(this.stereotypes) && isStubArray(this.tags)
-    );
-  }
-
   protected override get _elementHashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.PROFILE,

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

@@ -16,25 +16,16 @@
 
 import { type Hashable, hashArray, uuid } from '@finos/legend-shared';
 import { CORE_HASH_STRUCTURE } from '../../../../../MetaModelConst';
-import {
-  type GenericTypeReference,
-  GenericTypeExplicitReference,
-} from './GenericTypeReference';
-import { Multiplicity } from './Multiplicity';
-import { GenericType } from './GenericType';
-import type { Class } from './Class';
+import type { GenericTypeReference } from './GenericTypeReference';
+import type { Multiplicity } from './Multiplicity';
 import type { AbstractProperty, PropertyOwner } from './AbstractProperty';
 import type { AnnotatedElement } from './AnnotatedElement';
 import type { TaggedValue } from './TaggedValue';
-import { type Stubable, isStubArray } from '../../../../../helpers/Stubable';
-import type { Type } from './Type';
 import type { StereotypeReference } from './StereotypeReference';
 
-export class Property
-  implements AbstractProperty, AnnotatedElement, Hashable, Stubable
-{
-  readonly uuid = uuid();
-  owner: PropertyOwner; // readonly
+export class Property implements AbstractProperty, AnnotatedElement, Hashable {
+  readonly _UUID = uuid();
+  readonly _OWNER: PropertyOwner;
 
   name: string;
   multiplicity: Multiplicity;
@@ -51,23 +42,7 @@ export class Property
     this.name = name;
     this.multiplicity = multiplicity;
     this.genericType = genericType;
-    this.owner = owner;
-  }
-
-  static createStub = (type: Type, _class: Class): Property =>
-    new Property(
-      '',
-      new Multiplicity(1, 1),
-      GenericTypeExplicitReference.create(new GenericType(type)),
-      _class,
-    );
-  get isStub(): boolean {
-    return (
-      !this.name &&
-      this.genericType.isStub &&
-      isStubArray(this.stereotypes) &&
-      isStubArray(this.taggedValues)
-    );
+    this._OWNER = owner;
   }
 
   get hashCode(): string {

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

@@ -21,16 +21,13 @@ import {
   type PackageableElementReference,
   type PackageableElementImplicitReference,
 } from '../PackageableElementReference';
-import type { Stubable } from '../../../../../helpers/Stubable';
 import { ReferenceWithOwner } from '../../Reference';
 import type { AbstractProperty } from './AbstractProperty';
 import type { Class } from './Class';
 import { Association } from './Association';
+import { getAssociatedPropertyClass } from '../../../../../helpers/DomainHelper';
 
-export abstract class PropertyReference
-  extends ReferenceWithOwner
-  implements Stubable
-{
+export abstract class PropertyReference extends ReferenceWithOwner {
   override readonly ownerReference: PackageableElementReference<
     Class | Association
   >;
@@ -45,10 +42,6 @@ export abstract class PropertyReference
     this.value = value;
   }
 
-  get isStub(): boolean {
-    return !this.value.isStub;
-  }
-
   get pointerHashCode(): string {
     return [
       CORE_HASH_STRUCTURE.PROPERTY_POINTER,
@@ -65,9 +58,9 @@ export class PropertyExplicitReference extends PropertyReference {
 
   private constructor(value: AbstractProperty) {
     const ownerReference = PackageableElementExplicitReference.create(
-      value.owner instanceof Association
-        ? value.owner.getPropertyAssociatedClass(value)
-        : value.owner,
+      value._OWNER instanceof Association
+        ? getAssociatedPropertyClass(value._OWNER, value)
+        : value._OWNER,
     );
     super(ownerReference, value);
     this.ownerReference = ownerReference;

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

@@ -16,22 +16,15 @@
 
 import { uuid } from '@finos/legend-shared';
 import type { Profile } from './Profile';
-import type { Stubable } from '../../../../../helpers/Stubable';
 
-export class Stereotype implements Stubable {
-  readonly uuid = uuid();
-  owner: Profile;
+export class Stereotype {
+  readonly _UUID = uuid();
+  readonly _OWNER: Profile;
 
   value: string;
 
   constructor(owner: Profile, value: string) {
-    this.owner = owner;
+    this._OWNER = owner;
     this.value = value;
   }
-
-  static createStub = (profile: Profile): Stereotype =>
-    new Stereotype(profile, '');
-  get isStub(): boolean {
-    return !this.value;
-  }
 }