@finos/legend-graph 5.0.0 → 7.0.0

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

@@ -22,14 +22,10 @@ import {
   type PackageableElementImplicitReference,
 } from '../PackageableElementReference';
 import type { Profile } from './Profile';
-import type { Stubable } from '../../../../../helpers/Stubable';
 import { ReferenceWithOwner } from '../../Reference';
 import type { Stereotype } from './Stereotype';
 
-export abstract class StereotypeReference
-  extends ReferenceWithOwner
-  implements Stubable
-{
+export abstract class StereotypeReference extends ReferenceWithOwner {
   override readonly ownerReference: PackageableElementReference<Profile>;
   value: Stereotype;
 
@@ -42,10 +38,6 @@ export abstract class StereotypeReference
     this.value = value;
   }
 
-  get isStub(): boolean {
-    return !this.value.isStub;
-  }
-
   get pointerHashCode(): string {
     return [
       CORE_HASH_STRUCTURE.STEREOTYPE_POINTER,
@@ -62,7 +54,7 @@ export class StereotypeExplicitReference extends StereotypeReference {
 
   private constructor(value: Stereotype) {
     const ownerReference = PackageableElementExplicitReference.create(
-      value.owner,
+      value._OWNER,
     );
     super(ownerReference, value);
     this.ownerReference = ownerReference;

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

@@ -16,21 +16,15 @@
 
 import { uuid } from '@finos/legend-shared';
 import type { Profile } from './Profile';
-import type { Stubable } from '../../../../../helpers/Stubable';
 
-export class Tag implements Stubable {
-  readonly uuid = uuid();
-  owner: Profile;
+export class Tag {
+  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): Tag => new Tag(profile, '');
-  get isStub(): boolean {
-    return !this.value;
-  }
 }

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

@@ -23,13 +23,9 @@ import {
 } from '../PackageableElementReference';
 import type { Profile } from './Profile';
 import type { Tag } from './Tag';
-import type { Stubable } from '../../../../../helpers/Stubable';
 import { ReferenceWithOwner } from '../../Reference';
 
-export abstract class TagReference
-  extends ReferenceWithOwner
-  implements Stubable
-{
+export abstract class TagReference extends ReferenceWithOwner {
   override readonly ownerReference: PackageableElementReference<Profile>;
   value: Tag;
 
@@ -42,10 +38,6 @@ export abstract class TagReference
     this.value = value;
   }
 
-  get isStub(): boolean {
-    return !this.value.isStub;
-  }
-
   get pointerHashCode(): string {
     return [
       CORE_HASH_STRUCTURE.TAG_POINTER,
@@ -62,7 +54,7 @@ export class TagExplicitReference extends TagReference {
 
   private constructor(value: Tag) {
     const ownerReference = PackageableElementExplicitReference.create(
-      value.owner,
+      value._OWNER,
     );
     super(ownerReference, value);
     this.ownerReference = ownerReference;

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

@@ -16,12 +16,10 @@
 
 import { hashArray, uuid, type Hashable } from '@finos/legend-shared';
 import { CORE_HASH_STRUCTURE } from '../../../../../MetaModelConst';
-import type { Tag } from './Tag';
-import type { Stubable } from '../../../../../helpers/Stubable';
-import { type TagReference, TagExplicitReference } from './TagReference';
+import type { TagReference } from './TagReference';
 
-export class TaggedValue implements Hashable, Stubable {
-  readonly uuid = uuid();
+export class TaggedValue implements Hashable {
+  readonly _UUID = uuid();
 
   tag: TagReference;
   value: string;
@@ -31,12 +29,6 @@ export class TaggedValue implements Hashable, Stubable {
     this.value = value;
   }
 
-  static createStub = (tag: Tag): TaggedValue =>
-    new TaggedValue(TagExplicitReference.create(tag), '');
-  get isStub(): boolean {
-    return !this.value && this.tag.isStub;
-  }
-
   get hashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.TAGGED_VALUE,

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

@@ -16,10 +16,4 @@
 
 import { PackageableElement } from '../PackageableElement';
 
-export abstract class Type extends PackageableElement {
-  // Use these for contravariant and covariant check
-  // See https://www.originate.com/cheat-codes-for-contravariance-and-covariance/
-  // See https://en.wikipedia.org/wiki/Covariance_and_contravariance_of_vectors
-  abstract isSubType(type: Type): boolean;
-  abstract isSuperType(type: Type): boolean;
-}
+export abstract class Type extends PackageableElement {}

package/src/models/metamodels/pure/packageableElements/externalFormat/schemaSet/DSLExternalFormat_Schema.ts

@@ -18,7 +18,7 @@ import { uuid, hashArray, type Hashable } from '@finos/legend-shared';
 import { DSL_EXTERNAL_FORMAT_HASH_STRUCTURE } from '../../../../../DSLExternalFormat_ModelUtils';
 
 export class Schema implements Hashable {
-  readonly uuid = uuid();
+  readonly _UUID = uuid();
 
   id?: string | undefined;
   location?: string | undefined;

package/src/models/metamodels/pure/packageableElements/fileGeneration/FileGenerationSpecification.ts

@@ -34,16 +34,6 @@ export class FileGenerationSpecification
     [];
   configurationProperties: ConfigurationProperty[] = [];
 
-  getConfigValue(name: string): unknown | undefined {
-    return this.getConfig(name)?.value;
-  }
-
-  getConfig(name: string): ConfigurationProperty | undefined {
-    return this.configurationProperties.find(
-      (property) => name === property.name,
-    );
-  }
-
   protected override get _elementHashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.FILE_GENERATION,

package/src/models/metamodels/pure/packageableElements/generationSpecification/GenerationSpecification.ts

@@ -14,16 +14,18 @@
  * limitations under the License.
  */
 
-import { CORE_HASH_STRUCTURE } from '../../../../../MetaModelConst';
+import {
+  CORE_HASH_STRUCTURE,
+  PackageableElementPointerType,
+} from '../../../../../MetaModelConst';
 import { type Hashable, hashArray } from '@finos/legend-shared';
 import {
   type PackageableElementVisitor,
   PackageableElement,
-  PACKAGEABLE_ELEMENT_POINTER_TYPE,
-  getElementPointerHashCode,
 } from '../PackageableElement';
 import type { PackageableElementReference } from '../PackageableElementReference';
 import type { FileGenerationSpecification } from '../fileGeneration/FileGenerationSpecification';
+import { hashElementPointer } from '../../../../../MetaModelUtils';
 
 // NOTE: As of now the tree only supports a linear order of generation. This is because the only use case is linear,
 // but the shape has been left as a tree to support 'branching' off in the future.
@@ -68,8 +70,8 @@ export class GenerationSpecification
       hashArray(this.generationNodes),
       hashArray(
         this.fileGenerations.map((fileGeneration) =>
-          getElementPointerHashCode(
-            PACKAGEABLE_ELEMENT_POINTER_TYPE.FILE_GENERATION,
+          hashElementPointer(
+            PackageableElementPointerType.FILE_GENERATION,
             fileGeneration.hashValue,
           ),
         ),

package/src/models/metamodels/pure/packageableElements/mapping/AssociationImplementation.ts

@@ -30,7 +30,8 @@ import type { InferableMappingElementIdValue } from './InferableMappingElementId
 export abstract class AssociationImplementation
   implements PropertyMappingsImplementation, Hashable
 {
-  readonly parent: Mapping;
+  readonly _PARENT: Mapping;
+
   association: PackageableElementReference<Association>;
   id: InferableMappingElementIdValue;
   stores: PackageableElementReference<Store>[] = [];
@@ -42,14 +43,10 @@ export abstract class AssociationImplementation
     association: PackageableElementExplicitReference<Association>,
   ) {
     this.id = id;
-    this.parent = parent;
+    this._PARENT = parent;
     this.association = association;
   }
 
-  get isStub(): boolean {
-    return !this.id.value;
-  }
-
   get hashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.ASSOCIATION_IMPLEMENTATION,

package/src/models/metamodels/pure/packageableElements/mapping/EnumValueMapping.ts

@@ -14,27 +14,28 @@
  * limitations under the License.
  */
 
-import { type Hashable, uuid, isNumber, hashArray } from '@finos/legend-shared';
+import {
+  type Hashable,
+  uuid,
+  isNumber,
+  hashArray,
+  isNonNullable,
+} from '@finos/legend-shared';
 import { CORE_HASH_STRUCTURE } from '../../../../../MetaModelConst';
 import { Enum } from '../domain/Enum';
-import type { Stubable } from '../../../../../helpers/Stubable';
 import type { EnumValueReference } from '../domain/EnumValueReference';
 
-export class SourceValue implements Stubable {
-  readonly uuid = uuid();
+export class SourceValue {
+  readonly _UUID = uuid();
 
   value: Enum | string | number | undefined;
 
   constructor(value: Enum | string | number | undefined) {
     this.value = value;
   }
-
-  get isStub(): boolean {
-    return this.value === undefined;
-  }
 }
 
-export class EnumValueMapping implements Hashable, Stubable {
+export class EnumValueMapping implements Hashable {
   enum: EnumValueReference;
   sourceValues: SourceValue[] = [];
 
@@ -42,25 +43,19 @@ export class EnumValueMapping implements Hashable, Stubable {
     this.enum = enumValue;
   }
 
-  get isStub(): boolean {
-    return !this.sourceValues.filter((value) => !value.isStub).length;
-  }
-
   get hashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.ENUM_VALUE_MAPPING,
       this.enum.value.name,
       hashArray(
-        this.sourceValues
-          .filter((value) => !value.isStub)
-          .map((sourceValue) => {
-            const value = sourceValue.value;
-            return isNumber(value)
-              ? value.toString()
-              : value instanceof Enum
-              ? `${value.owner.path}.${value.name}`
-              : value ?? '';
-          }),
+        this.sourceValues.filter(isNonNullable).map((sourceValue) => {
+          const value = sourceValue.value;
+          return isNumber(value)
+            ? value.toString()
+            : value instanceof Enum
+            ? `${value._OWNER.path}.${value.name}`
+            : value ?? '';
+        }),
       ),
     ]);
   }

package/src/models/metamodels/pure/packageableElements/mapping/EnumerationMapping.ts

@@ -14,26 +14,21 @@
  * limitations under the License.
  */
 
-import { hashArray, type Hashable } from '@finos/legend-shared';
+import { hashArray, isNonNullable, type Hashable } from '@finos/legend-shared';
 import { CORE_HASH_STRUCTURE } from '../../../../../MetaModelConst';
-import {
-  type PackageableElementReference,
-  type OptionalPackageableElementReference,
-  PackageableElementExplicitReference,
-  OptionalPackageableElementExplicitReference,
+import type {
+  PackageableElementReference,
+  OptionalPackageableElementReference,
 } from '../PackageableElementReference';
 import type { Mapping } from './Mapping';
 import type { Enumeration } from '../domain/Enumeration';
 import type { EnumValueMapping } from './EnumValueMapping';
 import type { Type } from '../domain/Type';
-import { type Stubable, isStubArray } from '../../../../../helpers/Stubable';
-import {
-  type InferableMappingElementIdValue,
-  InferableMappingElementIdExplicitValue,
-} from './InferableMappingElementId';
+import type { InferableMappingElementIdValue } from './InferableMappingElementId';
+
+export class EnumerationMapping implements Hashable {
+  readonly _PARENT: Mapping;
 
-export class EnumerationMapping implements Hashable, Stubable {
-  readonly parent: Mapping;
   enumeration: PackageableElementReference<Enumeration>;
   id: InferableMappingElementIdValue;
   sourceType: OptionalPackageableElementReference<Type>;
@@ -47,24 +42,10 @@ export class EnumerationMapping implements Hashable, Stubable {
   ) {
     this.id = id;
     this.enumeration = enumeration;
-    this.parent = parent;
+    this._PARENT = parent;
     this.sourceType = sourceType;
   }
 
-  static createStub = (
-    enumeration: Enumeration,
-    mapping: Mapping,
-  ): EnumerationMapping =>
-    new EnumerationMapping(
-      InferableMappingElementIdExplicitValue.create('', enumeration.path),
-      PackageableElementExplicitReference.create(enumeration),
-      mapping,
-      OptionalPackageableElementExplicitReference.create<Type>(undefined),
-    );
-  get isStub(): boolean {
-    return !this.id.value && isStubArray(this.enumValueMappings);
-  }
-
   get hashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.ENUMERATION_MAPPING,
@@ -72,13 +53,17 @@ export class EnumerationMapping implements Hashable, Stubable {
       this.enumeration.hashValue,
       // If there are no enum value mapping, source type means nothing since it's not in the protocol anyway
       this.enumValueMappings.filter(
-        (enumValueMapping) => !enumValueMapping.isStub,
+        // TODO: use `isStubbed_EnumValueMapping` when we refactor hashing
+        (enumValueMapping) =>
+          enumValueMapping.sourceValues.filter(isNonNullable).length,
       ).length
         ? this.sourceType.valueForSerialization ?? ''
         : '', // default source value when there is no element
       hashArray(
         this.enumValueMappings.filter(
-          (enumValueMapping) => !enumValueMapping.isStub,
+          // TODO: use `isStubbed_EnumValueMapping` when we refactor hashing
+          (enumValueMapping) =>
+            enumValueMapping.sourceValues.filter(isNonNullable).length,
         ),
       ),
     ]);

package/src/models/metamodels/pure/packageableElements/mapping/ExpectedOutputMappingTestAssert.ts

@@ -36,7 +36,9 @@ export class ExpectedOutputMappingTestAssert
 
   constructor(expectedOutput: string) {
     super();
-    /* @MARKER: Workaround for https://github.com/finos/legend-studio/issues/68 */
+    /**
+     * @workaround https://github.com/finos/legend-studio/issues/68
+     */
     this.expectedOutput = tryToMinifyLosslessJSONString(expectedOutput);
   }
 

package/src/models/metamodels/pure/packageableElements/mapping/InstanceSetImplementation.ts

@@ -27,10 +27,4 @@ export abstract class InstanceSetImplementation
   mappingClass?: MappingClass | undefined;
   propertyMappings: PropertyMapping[] = [];
   // aggregateSpecification: AggregateSpecification[0..1];
-
-  abstract getEmbeddedSetImplmentations(): InstanceSetImplementation[];
-  abstract findPropertyMapping(
-    propertyName: string,
-    targetId: string | undefined,
-  ): PropertyMapping | undefined;
 }

package/src/models/metamodels/pure/packageableElements/mapping/LocalMappingPropertyInfo.ts

@@ -18,17 +18,17 @@ import { hashArray, type Hashable } from '@finos/legend-shared';
 import type { Multiplicity } from '../domain/Multiplicity';
 import type { Type } from '../domain/Type';
 import { CORE_HASH_STRUCTURE } from '../../../../../MetaModelConst';
+import type { PackageableElementReference } from '../PackageableElementReference';
 
 export class LocalMappingPropertyInfo implements Hashable {
   localMappingProperty!: boolean;
-  // TODO: refactor this to use `PackageableElementReference`
-  localMappingPropertyType!: Type;
+  localMappingPropertyType!: PackageableElementReference<Type>;
   localMappingPropertyMultiplicity!: Multiplicity;
 
   get hashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.LOCAL_MAPPING_PROPERTY,
-      this.localMappingPropertyType.path,
+      this.localMappingPropertyType.hashValue,
       this.localMappingPropertyMultiplicity,
     ]);
   }

package/src/models/metamodels/pure/packageableElements/mapping/Mapping.ts

@@ -23,56 +23,16 @@ import {
   type PackageableElementVisitor,
   PackageableElement,
 } from '../PackageableElement';
-import { type Stubable, isStubArray } from '../../../../../helpers/Stubable';
 import type { MappingTest } from './MappingTest';
 import type { MappingInclude } from './MappingInclude';
 
-export class Mapping extends PackageableElement implements Hashable, Stubable {
+export class Mapping extends PackageableElement implements Hashable {
   includes: MappingInclude[] = [];
   classMappings: SetImplementation[] = [];
   enumerationMappings: EnumerationMapping[] = [];
   associationMappings: AssociationImplementation[] = [];
   tests: MappingTest[] = [];
 
-  get allOwnClassMappings(): SetImplementation[] {
-    return this.classMappings;
-  }
-
-  get allOwnEnumerationMappings(): EnumerationMapping[] {
-    return this.enumerationMappings;
-  }
-
-  /**
-   * Get all included mappings, accounted for loop and duplication (which should be caught by compiler)
-   */
-  get allIncludedMappings(): Mapping[] {
-    const visited = new Set<Mapping>();
-    visited.add(this);
-    const resolveIncludes = (_mapping: Mapping): void => {
-      _mapping.includes.forEach((incMapping) => {
-        if (!visited.has(incMapping.included.value)) {
-          visited.add(incMapping.included.value);
-          resolveIncludes(incMapping.included.value);
-        }
-      });
-    };
-    resolveIncludes(this);
-    visited.delete(this);
-    return Array.from(visited);
-  }
-
-  static createStub = (): Mapping => new Mapping('');
-
-  override get isStub(): boolean {
-    return (
-      super.isStub &&
-      // && isStubArray(this.includes)
-      isStubArray(this.associationMappings) &&
-      isStubArray(this.classMappings) &&
-      isStubArray(this.enumerationMappings)
-    );
-  }
-
   protected override get _elementHashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.MAPPING,

package/src/models/metamodels/pure/packageableElements/mapping/MappingInclude.ts

@@ -21,12 +21,13 @@ import type { Mapping } from './Mapping';
 import type { SubstituteStore } from './SubstituteStore';
 
 export class MappingInclude {
-  owner: Mapping;
+  readonly _OWNER: Mapping;
+
   included: PackageableElementReference<Mapping>;
   storeSubstitutions: SubstituteStore[] = [];
 
   constructor(owner: Mapping, included: PackageableElementReference<Mapping>) {
-    this.owner = owner;
+    this._OWNER = owner;
     this.included = included;
   }
 

package/src/models/metamodels/pure/packageableElements/mapping/MappingTest.ts

@@ -25,10 +25,15 @@ import {
 } from '../../../../../helpers/ValidationHelper';
 
 export class MappingTest implements Hashable {
-  readonly uuid = uuid();
+  readonly _UUID = uuid();
 
   name: string;
-  query: 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
+   */
+  query: RawLambda;
   inputData: InputData[] = [];
   assert: MappingTestAssert;
 
@@ -47,7 +52,8 @@ export class MappingTest implements Hashable {
   get validationResult(): ValidationIssue[] | undefined {
     let problems: ValidationIssue[] = [];
     // query
-    if (this.query.isStub) {
+    // TODO: use `isStubbed_RawLambda` when we refactor validation
+    if (!this.query.parameters && !this.query.body) {
       problems.push(
         createValidationError(['Mapping test query cannot be empty']),
       );

package/src/models/metamodels/pure/packageableElements/mapping/MergeOperationSetImplementation.ts

@@ -25,14 +25,13 @@ import {
   type OperationType,
   OperationSetImplementation,
 } from './OperationSetImplementation';
-import type { Stubable } from '../../../../../helpers/Stubable';
 import type { RawLambda } from '../../rawValueSpecification/RawLambda';
 import type { SetImplementationVisitor } from './SetImplementation';
 import { hashLambda } from '../../../../../MetaModelUtils';
 
 export class MergeOperationSetImplementation
   extends OperationSetImplementation
-  implements Hashable, Stubable
+  implements Hashable
 {
   validationFunction: RawLambda;
 
@@ -53,6 +52,7 @@ export class MergeOperationSetImplementation
       CORE_HASH_STRUCTURE.OPERATION_SET_IMPLEMENTATION,
       this.operation,
       hashArray(
+        // TODO: use `isStubbed_SetImplementationContainer` when we refactor hashing
         this.parameters.map((param) => param.setImplementation.value.id.value),
       ),
       hashLambda(

package/src/models/metamodels/pure/packageableElements/mapping/OperationSetImplementation.ts

@@ -14,11 +14,7 @@
  * 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 type { PackageableElementReference } from '../PackageableElementReference';
 import {
@@ -28,7 +24,6 @@ import {
 import type { SetImplementationContainer } from './SetImplementationContainer';
 import type { Mapping } from './Mapping';
 import type { Class } from '../domain/Class';
-import { type Stubable, isStubArray } from '../../../../../helpers/Stubable';
 import type { InferableMappingElementIdValue } from './InferableMappingElementId';
 import type { InferableMappingElementRoot } from './InferableMappingElementRoot';
 
@@ -39,16 +34,9 @@ export enum OperationType {
   MERGE = 'MERGE',
 }
 
-// TODO: to be moved out of metamodel
-export const getClassMappingOperationType = (value: string): OperationType =>
-  guaranteeNonNullable(
-    Object.values(OperationType).find((type) => type === value),
-    `Encountered unsupproted class mapping operation type '${value}'`,
-  );
-
 export class OperationSetImplementation
   extends SetImplementation
-  implements Hashable, Stubable
+  implements Hashable
 {
   parameters: SetImplementationContainer[] = [];
   operation: OperationType;
@@ -64,49 +52,12 @@ export class OperationSetImplementation
     this.operation = operation;
   }
 
-  /**
-   * Get all leaf impls of an operation Set Implementation. Accounts for loops and duplication (which should be caught by compiler).
-   */
-  get leafSetImplementations(): SetImplementation[] {
-    return this.childSetImplementations.filter(
-      (si) => !(si instanceof OperationSetImplementation),
-    );
-  }
-
-  get childSetImplementations(): SetImplementation[] {
-    const visitedOperations = new Set<OperationSetImplementation>();
-    visitedOperations.add(this);
-    const _leaves = new Set<SetImplementation>();
-    const resolveleafSetImps = (
-      _opSetImpl: OperationSetImplementation,
-    ): void => {
-      _opSetImpl.parameters.forEach((p) => {
-        const setImp = p.setImplementation.value;
-        if (
-          setImp instanceof OperationSetImplementation &&
-          !visitedOperations.has(setImp)
-        ) {
-          visitedOperations.add(setImp);
-          resolveleafSetImps(setImp);
-        } else {
-          _leaves.add(setImp);
-        }
-      });
-    };
-    resolveleafSetImps(this);
-    visitedOperations.delete(this);
-    return Array.from(_leaves).concat(Array.from(visitedOperations));
-  }
-
-  override get isStub(): boolean {
-    return super.isStub && isStubArray(this.parameters);
-  }
-
   override get hashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.OPERATION_SET_IMPLEMENTATION,
       this.operation,
       hashArray(
+        // TODO: use `isStubbed_SetImplementationContainer` when we refactor hashing
         this.parameters.map((param) => param.setImplementation.value.id.value),
       ),
     ]);