@finos/legend-graph 10.1.0 → 11.0.0

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

@@ -14,14 +14,13 @@
  * limitations under the License.
  */
 
-import { assertType } from '@finos/legend-shared';
 import type { PackageableElement } from './PackageableElement.js';
 import type { Section } from './section/Section.js';
-import { RequiredReference, OptionalReference } from '../Reference.js';
+import { Reference } from '../Reference.js';
 
 export abstract class PackageableElementReference<
   T extends PackageableElement,
-> extends RequiredReference {
+> extends Reference {
   value: T;
 
   protected constructor(value: T) {
@@ -141,131 +140,3 @@ export class PackageableElementImplicitReference<
     return currentElementPath;
   }
 }
-
-export abstract class OptionalPackageableElementReference<
-  T extends PackageableElement,
-> extends OptionalReference {
-  value?: T | undefined;
-
-  protected constructor(value: T | undefined) {
-    super();
-    this.value = value;
-  }
-
-  abstract get valueForSerialization(): string | undefined;
-}
-
-export class OptionalPackageableElementExplicitReference<
-  T extends PackageableElement,
-> extends OptionalPackageableElementReference<T> {
-  private constructor(value: T | undefined) {
-    super(value);
-  }
-
-  static create<V extends PackageableElement>(
-    value: V | undefined,
-  ): OptionalPackageableElementExplicitReference<V> {
-    return new OptionalPackageableElementExplicitReference(value);
-  }
-
-  get valueForSerialization(): string | undefined {
-    return this.value?.path;
-  }
-}
-
-export class OptionalPackageableElementImplicitReference<
-  T extends PackageableElement,
-> extends OptionalPackageableElementReference<T> {
-  readonly initialResolvedPath?: string | undefined;
-  readonly input?: string | undefined;
-  readonly parentSection?: Section | undefined;
-  readonly skipSectionCheck?: boolean | undefined;
-
-  private constructor(
-    value: T | undefined,
-    input: string | undefined,
-    parentSection: Section | undefined,
-    skipSectionCheck: boolean | undefined,
-  ) {
-    super(value);
-    this.initialResolvedPath = value?.path;
-    this.input = input;
-    this.parentSection = parentSection;
-    this.skipSectionCheck = skipSectionCheck;
-  }
-
-  static create<V extends PackageableElement>(
-    value: V | undefined,
-    input: string | undefined,
-  ): OptionalPackageableElementImplicitReference<V> {
-    return new OptionalPackageableElementImplicitReference(
-      value,
-      input,
-      undefined,
-      true,
-    );
-  }
-
-  /**
-   * Use this creator method when the reference is created by
-   * resolving imports using section majorly when building the graph.
-   */
-  static resolveFromSection<V extends PackageableElement>(
-    value: V | undefined,
-    input: string | undefined,
-    parentSection: Section | undefined,
-  ): OptionalPackageableElementImplicitReference<V> {
-    return new OptionalPackageableElementImplicitReference(
-      value,
-      input,
-      parentSection,
-      false,
-    );
-  }
-
-  get valueForSerialization(): string | undefined {
-    const currentElementPath = this.value?.path;
-    // NOTE: `skipSectionCheck` flag's effect should only kick in if the value
-    // is not different than the original value
-    if (
-      this.skipSectionCheck &&
-      this.initialResolvedPath === currentElementPath
-    ) {
-      return this.input;
-    }
-    // when the parent section does not exist or has been deleted
-    if (
-      this.parentSection === undefined ||
-      this.parentSection._OWNER.isDeleted
-    ) {
-      return currentElementPath;
-    }
-    // the current element is the same as the inferred one
-    if (this.initialResolvedPath === currentElementPath) {
-      return this.input;
-    }
-    return currentElementPath;
-  }
-}
-
-export const optionalizePackageableElementReference = <
-  V extends PackageableElement,
->(
-  reference: PackageableElementReference<V> | undefined,
-): OptionalPackageableElementReference<V> => {
-  if (!reference || reference instanceof PackageableElementExplicitReference) {
-    return OptionalPackageableElementExplicitReference.create(reference?.value);
-  }
-  assertType(reference, PackageableElementImplicitReference);
-  if (reference.skipSectionCheck) {
-    return OptionalPackageableElementImplicitReference.create(
-      reference.value,
-      reference.input,
-    );
-  }
-  return OptionalPackageableElementImplicitReference.resolveFromSection(
-    reference.value,
-    reference.input,
-    reference.parentSection,
-  );
-};

package/src/models/metamodels/pure/packageableElements/externalFormat/store/DSLExternalFormat_Binding.ts

@@ -17,13 +17,16 @@
 import { hashArray, type Hashable } from '@finos/legend-shared';
 import type { SchemaSet } from '../schemaSet/DSLExternalFormat_SchemaSet.js';
 import { Store } from '../../store/Store.js';
-import type { OptionalPackageableElementReference } from '../../PackageableElementReference.js';
 import type { ModelUnit } from './DSLExternalFormat_ModelUnit.js';
 import type { PackageableElementVisitor } from '../../PackageableElement.js';
 import { DSL_EXTERNAL_FORMAT_HASH_STRUCTURE } from '../../../../../DSLExternalFormat_ModelUtils.js';
+import type { PackageableElementReference } from '../../PackageableElementReference.js';
 
+// NOTE: in the metamodel, `Binding` extends `ModelStore`, we could consider doing the same
+// although this might not be trivial as we have a fair amount of logic around the special
+// handling of `ModelStore`
 export class Binding extends Store implements Hashable {
-  schemaSet!: OptionalPackageableElementReference<SchemaSet>;
+  schemaSet?: PackageableElementReference<SchemaSet> | undefined;
   schemaId?: string | undefined;
   contentType!: string;
   modelUnit!: ModelUnit;
@@ -32,7 +35,7 @@ export class Binding extends Store implements Hashable {
     return hashArray([
       DSL_EXTERNAL_FORMAT_HASH_STRUCTURE.BINDING,
       this.path,
-      this.schemaSet.valueForSerialization ?? '',
+      this.schemaSet?.valueForSerialization ?? '',
       this.schemaId ?? '',
       this.contentType,
       this.modelUnit,

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

@@ -16,10 +16,7 @@
 
 import { hashArray, isNonNullable, type Hashable } from '@finos/legend-shared';
 import { CORE_HASH_STRUCTURE } from '../../../../../MetaModelConst.js';
-import type {
-  PackageableElementReference,
-  OptionalPackageableElementReference,
-} from '../PackageableElementReference.js';
+import type { PackageableElementReference } from '../PackageableElementReference.js';
 import type { Mapping } from './Mapping.js';
 import type { Enumeration } from '../domain/Enumeration.js';
 import type { EnumValueMapping } from './EnumValueMapping.js';
@@ -31,14 +28,14 @@ export class EnumerationMapping implements Hashable {
 
   enumeration: PackageableElementReference<Enumeration>;
   id: InferableMappingElementIdValue;
-  sourceType: OptionalPackageableElementReference<Type>;
+  sourceType?: PackageableElementReference<Type> | undefined;
   enumValueMappings: EnumValueMapping[] = [];
 
   constructor(
     id: InferableMappingElementIdValue,
     enumeration: PackageableElementReference<Enumeration>,
     parent: Mapping,
-    sourceType: OptionalPackageableElementReference<Type>,
+    sourceType: PackageableElementReference<Type> | undefined,
   ) {
     this.id = id;
     this.enumeration = enumeration;
@@ -55,15 +52,19 @@ export class EnumerationMapping implements Hashable {
       this.enumValueMappings.filter(
         // TODO: use `isStubbed_EnumValueMapping` when we refactor hashing
         (enumValueMapping) =>
-          enumValueMapping.sourceValues.filter(isNonNullable).length,
+          enumValueMapping.sourceValues.filter((sourceValue) =>
+            isNonNullable(sourceValue.value),
+          ).length,
       ).length
-        ? this.sourceType.valueForSerialization ?? ''
+        ? this.sourceType?.valueForSerialization ?? ''
         : '', // default source value when there is no element
       hashArray(
         this.enumValueMappings.filter(
           // TODO: use `isStubbed_EnumValueMapping` when we refactor hashing
           (enumValueMapping) =>
-            enumValueMapping.sourceValues.filter(isNonNullable).length,
+            enumValueMapping.sourceValues.filter((sourceValue) =>
+              isNonNullable(sourceValue.value),
+            ).length,
         ),
       ),
     ]);

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

@@ -15,20 +15,20 @@
  */
 
 import {
-  type OptionalPackageableElementReference,
-  OptionalPackageableElementExplicitReference,
+  type PackageableElementReference,
+  PackageableElementExplicitReference,
 } from '../PackageableElementReference.js';
 import type { Mapping } from './Mapping.js';
 import type { EnumerationMapping } from './EnumerationMapping.js';
-import { OptionalReferenceWithOwner } from '../../Reference.js';
+import { ReferenceWithOwner } from '../../Reference.js';
 
-export abstract class OptionalEnumerationMappingReference extends OptionalReferenceWithOwner {
-  override readonly ownerReference: OptionalPackageableElementReference<Mapping>;
-  value?: EnumerationMapping | undefined;
+export abstract class EnumerationMappingReference extends ReferenceWithOwner {
+  override readonly ownerReference: PackageableElementReference<Mapping>;
+  value: EnumerationMapping;
 
   protected constructor(
-    ownerReference: OptionalPackageableElementReference<Mapping>,
-    value: EnumerationMapping | undefined,
+    ownerReference: PackageableElementReference<Mapping>,
+    value: EnumerationMapping,
   ) {
     super(ownerReference);
     this.ownerReference = ownerReference;
@@ -38,24 +38,24 @@ export abstract class OptionalEnumerationMappingReference extends OptionalRefere
   abstract get valueForSerialization(): string | undefined;
 }
 
-export class OptionalEnumerationMappingExplicitReference extends OptionalEnumerationMappingReference {
-  override readonly ownerReference: OptionalPackageableElementReference<Mapping>;
+export class EnumerationMappingExplicitReference extends EnumerationMappingReference {
+  override readonly ownerReference: PackageableElementReference<Mapping>;
 
-  private constructor(value: EnumerationMapping | undefined) {
-    const ownerReference = OptionalPackageableElementExplicitReference.create(
-      value?._PARENT,
+  private constructor(value: EnumerationMapping) {
+    const ownerReference = PackageableElementExplicitReference.create(
+      value._PARENT,
     );
     super(ownerReference, value);
     this.ownerReference = ownerReference;
   }
 
   static create(
-    value: EnumerationMapping | undefined,
-  ): OptionalEnumerationMappingExplicitReference {
-    return new OptionalEnumerationMappingExplicitReference(value);
+    value: EnumerationMapping,
+  ): EnumerationMappingExplicitReference {
+    return new EnumerationMappingExplicitReference(value);
   }
 
-  get valueForSerialization(): string | undefined {
-    return this.value?.id.value;
+  get valueForSerialization(): string {
+    return this.value.id.value;
   }
 }

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

@@ -18,7 +18,6 @@ import { hashArray, type Hashable } from '@finos/legend-shared';
 import { CORE_HASH_STRUCTURE } from '../../../../../MetaModelConst.js';
 import type { PropertyReference } from '../domain/PropertyReference.js';
 import type { PropertyMappingsImplementation } from './PropertyMappingsImplementation.js';
-import type { SetImplementation } from './SetImplementation.js';
 import type { PurePropertyMapping } from '../store/modelToModel/mapping/PurePropertyMapping.js';
 import type { FlatDataPropertyMapping } from '../store/flatData/mapping/FlatDataPropertyMapping.js';
 import type { EmbeddedFlatDataPropertyMapping } from '../store/flatData/mapping/EmbeddedFlatDataPropertyMapping.js';
@@ -29,6 +28,7 @@ import type { InlineEmbeddedRelationalInstanceSetImplementation } from '../store
 import type { AggregationAwarePropertyMapping } from './aggregationAware/AggregationAwarePropertyMapping.js';
 import type { XStorePropertyMapping } from './xStore/XStorePropertyMapping.js';
 import type { LocalMappingPropertyInfo } from './LocalMappingPropertyInfo.js';
+import type { SetImplementationReference } from './SetImplementationReference.js';
 
 export interface PropertyMappingVisitor<T> {
   visit_PropertyMapping(propertyMapping: PropertyMapping): T;
@@ -64,41 +64,45 @@ export abstract class PropertyMapping implements Hashable {
 
   property: PropertyReference;
   /**
-   * NOTE: in case the holder of this property mapping is an embedded property mapping,
-   * that embedded property mapping is considered the source otherwise, it is always
-   * the top/root `InstanceSetImplementation` that is considered the source implementation
+   * In Pure, these fields are defined as string and not properly resolved, perhaps because of
+   * the fact that in Pure, we allow mappings which contain class mapping IDs pointing at
+   * another mapping's class mappings. In Pure/Engine, we let this pass compilation phase.
+   * In Studio, we disallow this. This makes it hard for users to migrate to Studio.
+   * We should think of a strategy to make things loadable in Studio, but disallow users
+   * to make changes if they have this kind of error in their graph.
    *
-   * TODO: change this to use `SetImplemenetationReference`
-   */
-  sourceSetImplementation: SetImplementation;
-  /**
-   * NOTE: in Pure, we actually only store `targetId` and `sourceId` instead of the
-   * reference but for convenience and graph completeness validation purpose we will
-   * resolve to the actual set implementations here
+   * See https://github.com/finos/legend-studio/issues/880
+   *
+   * NOTE: We might not be able to resolve `targetSetImplementation` for all `target` IDs hence
+   * defined as optional for now. We might need to come back and re-visit this decision. Note that
+   * one quirky thing is that the metamodel in Pure has these fields as string pointers, even
+   * when these are not resolvable, the field is set to empty string. We should solidify our
+   * understand about these fields.
    *
-   * TODO: change this to use `OptionalSetImplemenetationReference`
+   * @discrepancy model
    */
-  targetSetImplementation?: SetImplementation | undefined;
+  sourceSetImplementation: SetImplementationReference;
+  targetSetImplementation?: SetImplementationReference | undefined;
   localMappingProperty?: LocalMappingPropertyInfo | undefined;
   // store?: Store | undefined;
 
   constructor(
     owner: PropertyMappingsImplementation,
     property: PropertyReference,
-    source: SetImplementation,
-    target?: SetImplementation,
+    source: SetImplementationReference,
+    target: SetImplementationReference | undefined,
   ) {
     this._OWNER = owner;
     this.sourceSetImplementation = source;
-    this.targetSetImplementation = target;
     this.property = property;
+    this.targetSetImplementation = target;
   }
 
   get hashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.PROPERTY_MAPPING,
       this.property.pointerHashCode,
-      this.targetSetImplementation?.id.value ?? '',
+      this.targetSetImplementation?.value.id.value ?? '',
       this.localMappingProperty ?? '',
     ]);
   }

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

@@ -15,19 +15,12 @@
  */
 
 import {
-  type PackageableElementImplicitReference,
-  type OptionalPackageableElementImplicitReference,
   type PackageableElementReference,
-  type OptionalPackageableElementReference,
   PackageableElementExplicitReference,
-  OptionalPackageableElementExplicitReference,
 } from '../PackageableElementReference.js';
 import type { Mapping } from './Mapping.js';
 import type { SetImplementation } from './SetImplementation.js';
-import {
-  OptionalReferenceWithOwner,
-  ReferenceWithOwner,
-} from '../../Reference.js';
+import { ReferenceWithOwner } from '../../Reference.js';
 
 export abstract class SetImplementationReference extends ReferenceWithOwner {
   override readonly ownerReference: PackageableElementReference<Mapping>;
@@ -41,6 +34,8 @@ export abstract class SetImplementationReference extends ReferenceWithOwner {
     this.ownerReference = ownerReference;
     this.value = value;
   }
+
+  abstract get valueForSerialization(): string | undefined;
 }
 
 export class SetImplementationExplicitReference extends SetImplementationReference {
@@ -57,77 +52,33 @@ export class SetImplementationExplicitReference extends SetImplementationReferen
   static create(value: SetImplementation): SetImplementationExplicitReference {
     return new SetImplementationExplicitReference(value);
   }
-}
-
-export class SetImplementationImplicitReference extends SetImplementationReference {
-  override readonly ownerReference: PackageableElementImplicitReference<Mapping>;
 
-  private constructor(
-    ownerReference: PackageableElementImplicitReference<Mapping>,
-    value: SetImplementation,
-  ) {
-    super(ownerReference, value);
-    this.ownerReference = ownerReference;
-  }
-
-  static create(
-    ownerReference: PackageableElementImplicitReference<Mapping>,
-    value: SetImplementation,
-  ): SetImplementationImplicitReference {
-    return new SetImplementationImplicitReference(ownerReference, value);
-  }
-}
-
-export abstract class OptionalSetImplementationReference extends OptionalReferenceWithOwner {
-  override readonly ownerReference: OptionalPackageableElementReference<Mapping>;
-  value?: SetImplementation | undefined;
-
-  protected constructor(
-    ownerReference: OptionalPackageableElementReference<Mapping>,
-    value: SetImplementation | undefined,
-  ) {
-    super(ownerReference);
-    this.ownerReference = ownerReference;
-    this.value = value;
+  get valueForSerialization(): string | undefined {
+    return this.value.id.value;
   }
 }
 
-export class OptionalSetImplementationExplicitReference extends OptionalSetImplementationReference {
-  override readonly ownerReference: OptionalPackageableElementReference<Mapping>;
+export class SetImplementationImplicitReference extends SetImplementationReference {
+  override readonly ownerReference: PackageableElementReference<Mapping>;
+  readonly input?: string | undefined;
 
-  private constructor(value: SetImplementation | undefined) {
-    const ownerReference = OptionalPackageableElementExplicitReference.create(
-      value?._PARENT,
+  private constructor(value: SetImplementation, input: string | undefined) {
+    const ownerReference = PackageableElementExplicitReference.create(
+      value._PARENT,
     );
     super(ownerReference, value);
     this.ownerReference = ownerReference;
+    this.input = input;
   }
 
   static create(
     value: SetImplementation,
-  ): OptionalSetImplementationExplicitReference {
-    return new OptionalSetImplementationExplicitReference(value);
-  }
-}
-
-export class OptionalSetImplementationImplicitReference extends OptionalSetImplementationReference {
-  override readonly ownerReference: OptionalPackageableElementReference<Mapping>;
-
-  private constructor(
-    ownerReference: OptionalPackageableElementImplicitReference<Mapping>,
-    value: SetImplementation | undefined,
-  ) {
-    super(ownerReference, value);
-    this.ownerReference = ownerReference;
+    input: string | undefined,
+  ): SetImplementationImplicitReference {
+    return new SetImplementationImplicitReference(value, input);
   }
 
-  static create(
-    ownerReference: PackageableElementImplicitReference<Mapping>,
-    value: SetImplementation,
-  ): OptionalSetImplementationImplicitReference {
-    return new OptionalSetImplementationImplicitReference(
-      ownerReference,
-      value,
-    );
+  get valueForSerialization(): string | undefined {
+    return this.input;
   }
 }

package/src/models/metamodels/pure/packageableElements/service/MultiExecutionServiceTestResult.ts

@@ -0,0 +1,21 @@
+/**
+ * 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 { TestResult } from '../../test/result/TestResult.js';
+
+export class MultiExecutionServiceTestResult extends TestResult {
+  keyIndexedTestResults: Map<string, TestResult> = new Map();
+}

package/src/models/metamodels/pure/packageableElements/store/flatData/mapping/EmbeddedFlatDataPropertyMapping.ts

@@ -22,10 +22,7 @@ import type {
   PropertyMapping,
   PropertyMappingVisitor,
 } from '../../../mapping/PropertyMapping.js';
-import type {
-  SetImplementationVisitor,
-  SetImplementation,
-} from '../../../mapping/SetImplementation.js';
+import type { SetImplementationVisitor } from '../../../mapping/SetImplementation.js';
 import type { Class } from '../../../domain/Class.js';
 import type { InstanceSetImplementation } from '../../../mapping/InstanceSetImplementation.js';
 import type { PropertyMappingsImplementation } from '../../../mapping/PropertyMappingsImplementation.js';
@@ -35,6 +32,7 @@ import type { PackageableElementReference } from '../../../PackageableElementRef
 import { InferableMappingElementRootExplicitValue } from '../../../mapping/InferableMappingElementRoot.js';
 import type { MappingClass } from '../../../mapping/MappingClass.js';
 import { FlatDataPropertyMapping } from './FlatDataPropertyMapping.js';
+import type { SetImplementationReference } from '../../../mapping/SetImplementationReference.js';
 
 /**
  * We can think of embedded property mappings as a 'gateway' from one set of property mappings to another. They are in a sense
@@ -45,7 +43,7 @@ import { FlatDataPropertyMapping } from './FlatDataPropertyMapping.js';
  * 1. Javascript only support single inheritance unlike Pure
  * 2. In the general mental model, it is more sensible to think of embedded property mapping as a property mapping rather than a class mapping because
  * despite the fact that it has the shape similar to a class mapping and it can contain multiple property mappings, it itselt is not a class mapping, it must
- * exsit "embedded" within a property mapping.
+ * exist "embedded" within a property mapping.
  */
 export class EmbeddedFlatDataPropertyMapping
   extends AbstractFlatDataPropertyMapping
@@ -65,10 +63,10 @@ export class EmbeddedFlatDataPropertyMapping
     owner: PropertyMappingsImplementation,
     property: PropertyReference,
     rootInstanceSetImplementation: InstanceSetImplementation,
-    source: SetImplementation,
+    source: SetImplementationReference,
     _class: PackageableElementReference<Class>,
     id: InferableMappingElementIdValue,
-    target?: SetImplementation,
+    target: SetImplementationReference | undefined,
   ) {
     super(owner, property, source, target);
     this.class = _class;

package/src/models/metamodels/pure/packageableElements/store/flatData/mapping/FlatDataPropertyMapping.ts

@@ -18,17 +18,17 @@ import { CORE_HASH_STRUCTURE } from '../../../../../../../MetaModelConst.js';
 import { hashArray, type Hashable } from '@finos/legend-shared';
 import type { RawLambda } from '../../../../rawValueSpecification/RawLambda.js';
 import { AbstractFlatDataPropertyMapping } from './AbstractFlatDataPropertyMapping.js';
-import type { SetImplementation } from '../../../mapping/SetImplementation.js';
 import type { PropertyMappingsImplementation } from '../../../mapping/PropertyMappingsImplementation.js';
 import type { PropertyReference } from '../../../domain/PropertyReference.js';
 import type { PropertyMappingVisitor } from '../../../mapping/PropertyMapping.js';
-import { OptionalEnumerationMappingExplicitReference } from '../../../mapping/EnumerationMappingReference.js';
+import type { EnumerationMappingReference } from '../../../mapping/EnumerationMappingReference.js';
+import type { SetImplementationReference } from '../../../mapping/SetImplementationReference.js';
 
 export class FlatDataPropertyMapping
   extends AbstractFlatDataPropertyMapping
   implements Hashable
 {
-  transformer = OptionalEnumerationMappingExplicitReference.create(undefined);
+  transformer?: EnumerationMappingReference | undefined;
   /**
    * Studio does not process value specification, they are left in raw JSON form
    *
@@ -40,8 +40,8 @@ export class FlatDataPropertyMapping
     owner: PropertyMappingsImplementation,
     property: PropertyReference,
     transform: RawLambda,
-    source: SetImplementation,
-    target?: SetImplementation,
+    source: SetImplementationReference,
+    target: SetImplementationReference | undefined,
   ) {
     super(owner, property, source, target);
     this.transform = transform;
@@ -51,7 +51,7 @@ export class FlatDataPropertyMapping
     return hashArray([
       CORE_HASH_STRUCTURE.FLAT_DATA_PROPERTY_MAPPING,
       super.hashCode,
-      this.transformer.valueForSerialization ?? '',
+      this.transformer?.valueForSerialization ?? '',
       this.transform,
     ]);
   }

package/src/models/metamodels/pure/packageableElements/store/modelToModel/mapping/PureInstanceSetImplementation.ts

@@ -21,10 +21,7 @@ import { InstanceSetImplementation } from '../../../mapping/InstanceSetImplement
 import type { PurePropertyMapping } from './PurePropertyMapping.js';
 import type { SetImplementationVisitor } from '../../../mapping/SetImplementation.js';
 import type { RawLambda } from '../../../../rawValueSpecification/RawLambda.js';
-import type {
-  PackageableElementReference,
-  OptionalPackageableElementReference,
-} from '../../../PackageableElementReference.js';
+import type { PackageableElementReference } from '../../../PackageableElementReference.js';
 import type { InferableMappingElementIdValue } from '../../../mapping/InferableMappingElementId.js';
 import type { Mapping } from '../../../mapping/Mapping.js';
 import type { InferableMappingElementRoot } from '../../../mapping/InferableMappingElementRoot.js';
@@ -34,7 +31,7 @@ export class PureInstanceSetImplementation
   implements Hashable
 {
   declare propertyMappings: PurePropertyMapping[];
-  srcClass: OptionalPackageableElementReference<Class>;
+  srcClass?: PackageableElementReference<Class> | undefined;
   /**
    * Studio does not process value specification, they are left in raw JSON form
    *
@@ -47,7 +44,7 @@ export class PureInstanceSetImplementation
     parent: Mapping,
     _class: PackageableElementReference<Class>,
     root: InferableMappingElementRoot,
-    srcClass: OptionalPackageableElementReference<Class>,
+    srcClass: PackageableElementReference<Class> | undefined,
   ) {
     super(id, parent, _class, root);
     this.srcClass = srcClass;
@@ -57,7 +54,7 @@ export class PureInstanceSetImplementation
     return hashArray([
       CORE_HASH_STRUCTURE.PURE_INSTANCE_SET_IMPLEMENTATION,
       super.hashCode,
-      this.srcClass.valueForSerialization ?? '',
+      this.srcClass?.valueForSerialization ?? '',
       this.filter ?? '',
       hashArray(
         this.propertyMappings.filter(