@finos/legend-graph 10.1.2 → 11.0.0

package/src/MetaModelConst.ts

@@ -27,6 +27,7 @@ export const TYPE_CAST_TOKEN = '@';
 export const ARROW_FUNCTION_TOKEN = '->';
 export const LATEST_DATE = '%latest';
 export const PARSER_SECTION_MARKER = '###';
+export const FUNCTION_SIGNATURE_MULTIPLICITY_INFINITE_TOKEN = 'MANY';
 
 export const RESERVERD_PACKAGE_NAMES = ['$implicit'];
 
@@ -125,6 +126,64 @@ export enum CORE_PURE_PATH {
   DATA_ELEMENT = 'meta::pure::data::DataElement',
 }
 
+export const PURE_DEPRECATED_STEREOTYPE = 'deprecated';
+
+export enum MILESTONING_STEREOTYPE {
+  BUSINESS_TEMPORAL = 'businesstemporal',
+  PROCESSING_TEMPORAL = 'processingtemporal',
+  BITEMPORAL = 'bitemporal',
+}
+
+export enum MILESTONING_VERSION_PROPERTY_SUFFIX {
+  ALL_VERSIONS = 'AllVersions',
+  ALL_VERSIONS_IN_RANGE = 'AllVersionsInRange',
+}
+
+export const MILESTONING_START_DATE_PARAMETER_NAME = 'start';
+export const MILESTONING_END_DATE_PARAMETER_NAME = 'end';
+export const DEFAULT_PROCESSING_DATE_MILESTONING_PARAMETER_NAME =
+  'processingDate';
+export const DEFAULT_BUSINESS_DATE_MILESTONING_PARAMETER_NAME = 'businessDate';
+
+export enum PackageableElementPointerType {
+  STORE = 'STORE',
+  MAPPING = 'MAPPING',
+  RUNTIME = 'RUNTIME',
+  FILE_GENERATION = 'FILE_GENERATION',
+  SERVICE = 'SERVICE',
+}
+
+export const DURATION_UNIT = 'meta::pure::functions::date::DurationUnit';
+export const DAY_OF_WEEK = 'meta::pure::functions::date::DayOfWeek';
+
+export enum SUPPORTED_FUNCTIONS {
+  // date-time value helper functions
+  TODAY = 'meta::pure::functions::date::today',
+  NOW = 'meta::pure::functions::date::now',
+  FIRST_DAY_OF_WEEK = 'meta::pure::functions::date::firstDayOfThisWeek',
+  FIRST_DAY_OF_MONTH = 'meta::pure::functions::date::firstDayOfThisMonth',
+  FIRST_DAY_OF_QUARTER = 'meta::pure::functions::date::firstDayOfThisQuarter',
+  FIRST_DAY_OF_YEAR = 'meta::pure::functions::date::firstDayOfThisYear',
+  PREVIOUS_DAY_OF_WEEK = 'meta::pure::functions::date::previousDayOfWeek',
+  IS_ON_DAY = 'meta::pure::functions::date::isOnDay',
+  IS_ON_OR_AFTER_DAY = 'meta::pure::functions::date::isOnOrAfterDay',
+  IS_AFTER_DAY = 'meta::pure::functions::date::isAfterDay',
+  IS_ON_OR_BEFORE_DAY = 'meta::pure::functions::date::isOnOrBeforeDay',
+  IS_BEFORE_DAY = 'meta::pure::functions::date::isBeforeDay',
+
+  // adjust time
+  MINUS = 'meta::pure::functions::math::minus',
+  ADJUST = 'meta::pure::functions::date::adjust',
+  // variables
+  LET = 'meta::pure::functions::lang::letFunction',
+}
+
+// Date formats
+export const DATE_TIME_FORMAT_WITH_MILLISECONDS =
+  "yyyy-MM-dd'T'HH:mm:ss.SSSxxxx";
+export const DATE_TIME_FORMAT = "yyyy-MM-dd'T'HH:mm:ssxxxx";
+export const DATE_FORMAT = 'yyyy-MM-dd';
+
 /**
  * The main point of maintaining this enum is to keep lessen magic string in hash computation
  * so that we are less error-prone in the process of defining hash.
@@ -345,59 +404,3 @@ export enum CORE_HASH_STRUCTURE {
   RELATIONAL_TDS = 'RELATIONAL_TDS',
   RELATIONAL_CSV_DATA_TABLE = 'RELATIONAL_CSV_DATA_TABLE',
 }
-
-export enum MILESTONING_STEREOTYPE {
-  BUSINESS_TEMPORAL = 'businesstemporal',
-  PROCESSING_TEMPORAL = 'processingtemporal',
-  BITEMPORAL = 'bitemporal',
-}
-
-export enum MILESTONING_VERSION_PROPERTY_SUFFIX {
-  ALL_VERSIONS = 'AllVersions',
-  ALL_VERSIONS_IN_RANGE = 'AllVersionsInRange',
-}
-
-export const MILESTONING_START_DATE_PARAMETER_NAME = 'start';
-export const MILESTONING_END_DATE_PARAMETER_NAME = 'end';
-export const DEFAULT_PROCESSING_DATE_MILESTONING_PARAMETER_NAME =
-  'processingDate';
-export const DEFAULT_BUSINESS_DATE_MILESTONING_PARAMETER_NAME = 'businessDate';
-
-export enum PackageableElementPointerType {
-  STORE = 'STORE',
-  MAPPING = 'MAPPING',
-  RUNTIME = 'RUNTIME',
-  FILE_GENERATION = 'FILE_GENERATION',
-  SERVICE = 'SERVICE',
-}
-
-export const DURATION_UNIT = 'meta::pure::functions::date::DurationUnit';
-export const DAY_OF_WEEK = 'meta::pure::functions::date::DayOfWeek';
-
-export enum SUPPORTED_FUNCTIONS {
-  // date-time value helper functions
-  TODAY = 'meta::pure::functions::date::today',
-  NOW = 'meta::pure::functions::date::now',
-  FIRST_DAY_OF_WEEK = 'meta::pure::functions::date::firstDayOfThisWeek',
-  FIRST_DAY_OF_MONTH = 'meta::pure::functions::date::firstDayOfThisMonth',
-  FIRST_DAY_OF_QUARTER = 'meta::pure::functions::date::firstDayOfThisQuarter',
-  FIRST_DAY_OF_YEAR = 'meta::pure::functions::date::firstDayOfThisYear',
-  PREVIOUS_DAY_OF_WEEK = 'meta::pure::functions::date::previousDayOfWeek',
-  IS_ON_DAY = 'meta::pure::functions::date::isOnDay',
-  IS_ON_OR_AFTER_DAY = 'meta::pure::functions::date::isOnOrAfterDay',
-  IS_AFTER_DAY = 'meta::pure::functions::date::isAfterDay',
-  IS_ON_OR_BEFORE_DAY = 'meta::pure::functions::date::isOnOrBeforeDay',
-  IS_BEFORE_DAY = 'meta::pure::functions::date::isBeforeDay',
-
-  // adjust time
-  MINUS = 'meta::pure::functions::math::minus',
-  ADJUST = 'meta::pure::functions::date::adjust',
-  // variables
-  LET = 'meta::pure::functions::lang::letFunction',
-}
-
-// Date Metamodel Constants
-export const DATE_TIME_FORMAT_WITH_MILLISECONDS =
-  "yyyy-MM-dd'T'HH:mm:ss.SSSxxxx";
-export const DATE_TIME_FORMAT = "yyyy-MM-dd'T'HH:mm:ssxxxx";
-export const DATE_FORMAT = 'yyyy-MM-dd';

package/src/graph/BasicModel.ts

@@ -101,7 +101,7 @@ export abstract class BasicModel {
   root: Package;
   readonly extensions: PureGraphExtension<PackageableElement>[] = [];
 
-  private elementSectionMap = new Map<string, Section>();
+  private elementSectionIndex = new Map<string, Section>();
 
   private sectionIndicesIndex = new Map<string, SectionIndex>();
   private readonly profilesIndex = new Map<string, Profile>();
@@ -237,7 +237,7 @@ export abstract class BasicModel {
   }
 
   getOwnNullableSection = (path: string): Section | undefined =>
-    this.elementSectionMap.get(path);
+    this.elementSectionIndex.get(path);
 
   getOwnNullableSectionIndex = (path: string): SectionIndex | undefined =>
     this.sectionIndicesIndex.get(path);
@@ -385,7 +385,7 @@ export abstract class BasicModel {
   }
 
   setOwnSection(path: string, val: Section): void {
-    this.elementSectionMap.set(path, val);
+    this.elementSectionIndex.set(path, val);
   }
   setOwnSectionIndex(path: string, val: SectionIndex): void {
     this.sectionIndicesIndex.set(path, val);
@@ -776,6 +776,6 @@ export abstract class BasicModel {
     // as such `this.sectionIndicesIndex.delete(sectionIndex.path)` won't work because the path
     // is without the package
     this.sectionIndicesIndex = new Map<string, SectionIndex>();
-    this.elementSectionMap = new Map<string, Section>();
+    this.elementSectionIndex = new Map<string, Section>();
   }
 }

package/src/graph/DependencyManager.ts

@@ -76,8 +76,8 @@ export class DependencyManager {
   /**
    * Here we create and index a graph for each dependency
    */
-  initialize(dependencyEntitiesMap: Map<string, Entity[]>): void {
-    Array.from(dependencyEntitiesMap.keys()).forEach((dependencyKey) => {
+  initialize(dependencyEntitiesIndex: Map<string, Entity[]>): void {
+    Array.from(dependencyEntitiesIndex.keys()).forEach((dependencyKey) => {
       // NOTE: all dependency models will share the dependency manager root package.
       this.projectDependencyModelsIndex.set(
         dependencyKey,

package/src/graph/PureModel.ts

@@ -144,8 +144,12 @@ export class SystemModel extends BasicModel {
 
   /**
    * NOTE: auto imports are for special types and profiles from system model
-   * such as `Any` or `doc` profiles.
-   * We prefer to initialize these only once
+   * such as `Any` or `doc` profiles. We don't actually build the packages here
+   * just resolving them, so we have to make sure whatever package we have as
+   * auto imports, we must have built some elements with such package, e.g.
+   *
+   * `meta::pure::metamodel::type::Any` covers `meta::pure::metamodel::type`
+   * `meta::pure::profiles::doc` covers `meta::pure::profiles`
    */
   initializeAutoImports(): void {
     this.autoImports = AUTO_IMPORTS.map((_package) =>
@@ -535,6 +539,10 @@ export class PureModel extends BasicModel {
     returnUndefOnError(() => this.getClass(path));
   getNullableMapping = (path: string): Mapping | undefined =>
     returnUndefOnError(() => this.getMapping(path));
+  getNullableService = (path: string): Service | undefined =>
+    returnUndefOnError(() => this.getService(path));
+  getNullableRuntime = (path: string): PackageableRuntime | undefined =>
+    returnUndefOnError(() => this.getRuntime(path));
   getNullableFileGeneration = (
     path: string,
   ): FileGenerationSpecification | undefined =>

package/src/graphManager/AbstractPureGraphManager.ts

@@ -27,7 +27,7 @@ import type {
 import type { FileGenerationSpecification } from '../models/metamodels/pure/packageableElements/fileGeneration/FileGenerationSpecification.js';
 import type { GenerationOutput } from './action/generation/GenerationOutput.js';
 import type { PackageableElement } from '../models/metamodels/pure/packageableElements/PackageableElement.js';
-import type { PureModel, CoreModel, SystemModel } from '../graph/PureModel.js';
+import { PureModel, CoreModel, SystemModel } from '../graph/PureModel.js';
 import type { Mapping } from '../models/metamodels/pure/packageableElements/mapping/Mapping.js';
 import type { Runtime } from '../models/metamodels/pure/packageableElements/runtime/Runtime.js';
 import type { DependencyManager } from '../graph/DependencyManager.js';
@@ -48,11 +48,11 @@ import type {
   RawExecutionPlan,
 } from '../models/metamodels/pure/executionPlan/ExecutionPlan.js';
 import type { ExecutionNode } from '../models/metamodels/pure/executionPlan/nodes/ExecutionNode.js';
-import type {
+import {
   ActionState,
-  Log,
-  ServerClientConfig,
-  TracerService,
+  type Log,
+  type ServerClientConfig,
+  type TracerService,
 } from '@finos/legend-shared';
 import type { LightQuery, Query } from './action/query/Query.js';
 import type { Entity } from '@finos/legend-model-storage';
@@ -71,7 +71,7 @@ import type { AssertFail } from '../models/metamodels/pure/test/assertion/status
 import type {
   MappingModelCoverageAnalysisResult,
   RawMappingModelCoverageAnalysisResult,
-} from './action/analytics/MappingAnalytics.js';
+} from './action/analytics/MappingModelCoverageAnalysis.js';
 
 export interface TEMPORARY__EngineSetupConfig {
   env: string;
@@ -129,6 +129,8 @@ export abstract class AbstractPureGraphManager {
       );
   }
 
+  abstract getSupportedProtocolVersion(): string;
+
   /**
    * TODO: we should not expose a fixed config like this, we probably
    * should not mention anything about engine because it is an internal construct
@@ -146,8 +148,6 @@ export abstract class AbstractPureGraphManager {
     },
   ): Promise<void>;
 
-  abstract getSupportedProtocolVersion(): string;
-
   // --------------------------------------------- Graph Builder ---------------------------------------------
 
   /**
@@ -163,16 +163,6 @@ export abstract class AbstractPureGraphManager {
     options?: GraphBuilderOptions,
   ): Promise<GraphBuilderReport>;
 
-  /**
-   * Process entities and build the main graph.
-   */
-  abstract buildGraph(
-    graph: PureModel,
-    entities: Entity[],
-    buildState: ActionState,
-    options?: GraphBuilderOptions,
-  ): Promise<GraphBuilderReport>;
-
   /**
    * Build immutable models which holds dependencies.
    * Dependency models MUST not depend on the main model.
@@ -185,7 +175,17 @@ export abstract class AbstractPureGraphManager {
     coreModel: CoreModel,
     systemModel: SystemModel,
     dependencyManager: DependencyManager,
-    dependencyEntitiesMap: Map<string, Entity[]>,
+    dependencyEntitiesIndex: Map<string, Entity[]>,
+    buildState: ActionState,
+    options?: GraphBuilderOptions,
+  ): Promise<GraphBuilderReport>;
+
+  /**
+   * Process entities and build the main graph.
+   */
+  abstract buildGraph(
+    graph: PureModel,
+    entities: Entity[],
     buildState: ActionState,
     options?: GraphBuilderOptions,
   ): Promise<GraphBuilderReport>;
@@ -210,6 +210,9 @@ export abstract class AbstractPureGraphManager {
   abstract pureCodeToLambda(
     lambda: string,
     lambdaId?: string,
+    options?: {
+      pruneSourceInformation?: boolean;
+    },
   ): Promise<RawLambda>;
   abstract lambdaToPureCode(
     lambda: RawLambda,
@@ -325,25 +328,25 @@ export abstract class AbstractPureGraphManager {
   // ------------------------------------------- Execute -------------------------------------------
 
   abstract executeMapping(
-    graph: PureModel,
-    mapping: Mapping,
     lambda: RawLambda,
+    mapping: Mapping,
     runtime: Runtime,
+    graph: PureModel,
     options?: ExecutionOptions,
   ): Promise<ExecutionResult>;
 
   abstract generateExecutionPlan(
-    graph: PureModel,
-    mapping: Mapping,
     lambda: RawLambda,
+    mapping: Mapping,
     runtime: Runtime,
+    graph: PureModel,
   ): Promise<RawExecutionPlan>;
 
   abstract debugExecutionPlanGeneration(
-    graph: PureModel,
-    mapping: Mapping,
     lambda: RawLambda,
+    mapping: Mapping,
     runtime: Runtime,
+    graph: PureModel,
   ): Promise<{ plan: RawExecutionPlan; debug: string }>;
 
   abstract buildExecutionPlan(
@@ -358,11 +361,11 @@ export abstract class AbstractPureGraphManager {
   abstract serializeExecutionNode(executionNode: ExecutionNode): object;
 
   abstract generateExecuteTestData(
-    graph: PureModel,
-    mapping: Mapping,
     lambda: RawLambda,
-    runtime: Runtime,
     parameters: (string | number | boolean)[],
+    mapping: Mapping,
+    runtime: Runtime,
+    graph: PureModel,
     options?: {
       // Anonymizes data by hashing any string values in the generated data
       anonymizeGeneratedData?: boolean;
@@ -376,13 +379,13 @@ export abstract class AbstractPureGraphManager {
    */
 
   abstract registerService(
-    graph: PureModel,
     service: Service,
+    graph: PureModel,
     groupId: string,
     artifactId: string,
+    version: string | undefined,
     server: string,
     executionMode: ServiceExecutionMode,
-    version: string | undefined,
   ): Promise<ServiceRegistrationResult>;
   abstract activateService(
     serviceUrl: string,
@@ -414,8 +417,8 @@ export abstract class AbstractPureGraphManager {
   // -------------------------------------- Analysis --------------------------------------
 
   abstract analyzeMappingModelCoverage(
-    graph: PureModel,
     mapping: Mapping,
+    graph: PureModel,
   ): Promise<MappingModelCoverageAnalysisResult>;
 
   abstract buildMappingModelCoverageAnalysisResult(
@@ -431,6 +434,26 @@ export abstract class AbstractPureGraphManager {
     },
   ): Entity;
 
+  async createEmptyGraph(options?: {
+    initializeSystem?: boolean;
+  }): Promise<PureModel> {
+    const extensionElementClasses = this.pluginManager
+      .getPureGraphPlugins()
+      .flatMap((plugin) => plugin.getExtraPureGraphExtensionClasses?.() ?? []);
+    const coreModel = new CoreModel(extensionElementClasses);
+    const systemModel = new SystemModel(extensionElementClasses);
+    if (options?.initializeSystem) {
+      await this.buildSystem(coreModel, systemModel, ActionState.create());
+      systemModel.initializeAutoImports();
+    }
+    const graph = new PureModel(
+      coreModel,
+      systemModel,
+      this.pluginManager.getPureGraphPlugins(),
+    );
+    return graph;
+  }
+
   // ------------------------------------------- Change detection -------------------------------------------
 
   abstract buildHashesIndex(entities: Entity[]): Promise<Map<string, string>>;

package/src/graphManager/GraphManagerEvent.ts

@@ -27,6 +27,7 @@ export enum GRAPH_MANAGER_EVENT {
   GRAPH_BUILDER_OTHER_ELEMENTS_BUILT = 'graph-manager.graph-builder.build-other-elements.success',
   GRAPH_BUILDER_COMPLETED = 'graph-manager.graph-builder.success',
 
+  GRAPH_SYSTEM_INITIALIZED = 'graph-manager.system-initialization.success',
   GRAPH_INITIALIZED = 'graph-manager.graph-initialization.success',
   GRAPH_DEPENDENCIES_FETCHED = 'graph-manager.fetch-dependencies.success',
   GRAPH_ENTITIES_FETCHED = 'graph-manager.entities-dependencies.success',

package/src/graphManager/action/analytics/{MappingAnalytics.ts → MappingModelCoverageAnalysis.ts}

@@ -17,7 +17,7 @@
 export type RawMappingModelCoverageAnalysisResult = object;
 
 export class MappedEntity {
-  readonly __NAME_TO_PROPERTY!: Map<string, MappedProperty>;
+  readonly __PROPERTIES_INDEX = new Map<string, MappedProperty>();
 
   path: string;
   properties: MappedProperty[];
@@ -25,8 +25,9 @@ export class MappedEntity {
   constructor(path: string, properties: MappedProperty[]) {
     this.path = path;
     this.properties = properties;
-    this.__NAME_TO_PROPERTY = new Map<string, MappedProperty>();
-    properties.map((p) => this.__NAME_TO_PROPERTY.set(p.name, p));
+    properties.forEach((property) =>
+      this.__PROPERTIES_INDEX.set(property.name, property),
+    );
   }
 }
 
@@ -59,13 +60,14 @@ export class EnumMappedProperty extends MappedProperty {
 }
 
 export class MappingModelCoverageAnalysisResult {
-  readonly __PATH_TO_ENTITY!: Map<string, MappedEntity>;
+  readonly __ENTITIES_INDEX = new Map<string, MappedEntity>();
 
   mappedEntities: MappedEntity[];
 
   constructor(mappedEntities: MappedEntity[]) {
     this.mappedEntities = mappedEntities;
-    this.__PATH_TO_ENTITY = new Map<string, MappedEntity>();
-    mappedEntities.map((e) => this.__PATH_TO_ENTITY.set(e.path, e));
+    mappedEntities.forEach((entity) =>
+      this.__ENTITIES_INDEX.set(entity.path, entity),
+    );
   }
 }

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

@@ -22,10 +22,7 @@ import {
   observable,
 } from 'mobx';
 import type { PackageableElement } from '../../../models/metamodels/pure/packageableElements/PackageableElement.js';
-import type {
-  OptionalPackageableElementReference,
-  PackageableElementReference,
-} from '../../../models/metamodels/pure/packageableElements/PackageableElementReference.js';
+import type { PackageableElementReference } from '../../../models/metamodels/pure/packageableElements/PackageableElementReference.js';
 import type { Multiplicity } from '../../../models/metamodels/pure/packageableElements/domain/Multiplicity.js';
 import type { InferableValue } from '../../../models/metamodels/pure/InferableValue.js';
 import type { PureGraphManagerPlugin } from '../../PureGraphManagerPlugin.js';
@@ -80,16 +77,6 @@ export const observe_PackageableElementReference = skipObserved(
     }),
 );
 
-export const observe_OptionalPackageableElementReference = skipObserved(
-  <T extends PackageableElement>(
-    metamodel: OptionalPackageableElementReference<T>,
-  ): OptionalPackageableElementReference<T> =>
-    makeObservable(metamodel, {
-      value: observable,
-      valueForSerialization: computed,
-    }),
-);
-
 export const observe_Multiplicity = skipObserved(
   (metamodel: Multiplicity): Multiplicity =>
     makeObservable(metamodel, {

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

@@ -25,7 +25,6 @@ import type { ModelUnit } from '../../../models/metamodels/pure/packageableEleme
 import {
   observe_PackageableElementReference,
   skipObserved,
-  observe_OptionalPackageableElementReference,
   observe_Abstract_PackageableElement,
 } from './CoreObserverHelper.js';
 import {
@@ -65,7 +64,9 @@ export const observe_Binding = skipObserved((metamodel: Binding): Binding => {
     _elementHashCode: override,
   });
 
-  observe_OptionalPackageableElementReference(metamodel.schemaSet);
+  if (metamodel.schemaSet) {
+    observe_PackageableElementReference(metamodel.schemaSet);
+  }
   observe_ModelUnit(metamodel.modelUnit);
 
   return metamodel;

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

@@ -25,7 +25,7 @@ import type { AggregationAwarePropertyMapping } from '../../../models/metamodels
 import type { AggregationAwareSetImplementation } from '../../../models/metamodels/pure/packageableElements/mapping/aggregationAware/AggregationAwareSetImplementation.js';
 import type { AssociationImplementation } from '../../../models/metamodels/pure/packageableElements/mapping/AssociationImplementation.js';
 import type { EnumerationMapping } from '../../../models/metamodels/pure/packageableElements/mapping/EnumerationMapping.js';
-import type { OptionalEnumerationMappingReference } from '../../../models/metamodels/pure/packageableElements/mapping/EnumerationMappingReference.js';
+import type { EnumerationMappingReference } from '../../../models/metamodels/pure/packageableElements/mapping/EnumerationMappingReference.js';
 import type {
   EnumValueMapping,
   SourceValue,
@@ -92,7 +92,6 @@ import {
   skipObserved,
   skipObservedWithContext,
   observe_Multiplicity,
-  observe_OptionalPackageableElementReference,
 } from './CoreObserverHelper.js';
 import {
   observe_EnumValueReference,
@@ -131,16 +130,14 @@ export const observe_Abstract_Store = (metamodel: Store): void => {
 
 // ------------------------------------- Mapping -------------------------------------
 
-export const observe_OptionalEnumerationMappingReference = skipObserved(
-  (
-    metamodel: OptionalEnumerationMappingReference,
-  ): OptionalEnumerationMappingReference => {
+export const observe_EnumerationMappingReference = skipObserved(
+  (metamodel: EnumerationMappingReference): EnumerationMappingReference => {
     makeObservable(metamodel, {
       value: observable,
       valueForSerialization: computed,
     });
 
-    observe_OptionalPackageableElementReference(metamodel.ownerReference);
+    observe_PackageableElementReference(metamodel.ownerReference);
 
     return metamodel;
   },
@@ -184,8 +181,10 @@ export const observe_Abstract_PropertyMapping = (
   });
 
   observe_PropertyReference(metamodel.property);
-  // TODO: source
-  // TODO: target
+  observe_SetImplementationReference(metamodel.sourceSetImplementation);
+  if (metamodel.targetSetImplementation) {
+    observe_SetImplementationReference(metamodel.targetSetImplementation);
+  }
   if (metamodel.localMappingProperty) {
     observe_LocalMappingPropertyInfo(metamodel.localMappingProperty);
   }
@@ -202,7 +201,9 @@ export const observe_PurePropertyMapping = skipObservedWithContext(
       hashCode: computed,
     });
 
-    observe_OptionalEnumerationMappingReference(metamodel.transformer);
+    if (metamodel.transformer) {
+      observe_EnumerationMappingReference(metamodel.transformer);
+    }
     observe_RawLambda(metamodel.transform);
 
     return metamodel;
@@ -425,7 +426,9 @@ export const observe_PureInstanceSetImplementation = skipObservedWithContext(
       hashCode: computed,
     });
 
-    observe_OptionalPackageableElementReference(metamodel.srcClass);
+    if (metamodel.srcClass) {
+      observe_PackageableElementReference(metamodel.srcClass);
+    }
     if (metamodel.filter) {
       observe_RawLambda(metamodel.filter);
     }
@@ -595,7 +598,9 @@ export const observe_EnumerationMapping = skipObserved(
 
     observe_PackageableElementReference(metamodel.enumeration);
     observe_InferableMappingElementIdValue(metamodel.id);
-    observe_OptionalPackageableElementReference(metamodel.sourceType);
+    if (metamodel.sourceType) {
+      observe_PackageableElementReference(metamodel.sourceType);
+    }
     metamodel.enumValueMappings.forEach(observe_EnumValueMapping);
 
     return metamodel;

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

@@ -36,7 +36,7 @@ const observe_PureGraphExtension = skipObserved(
 const observe_Abstract_BasicModel = (metamodel: BasicModel): void => {
   makeObservable<
     BasicModel,
-    | 'elementSectionMap'
+    | 'elementSectionIndex'
     | 'sectionIndicesIndex'
     | 'profilesIndex'
     | 'typesIndex'
@@ -51,7 +51,7 @@ const observe_Abstract_BasicModel = (metamodel: BasicModel): void => {
     | 'fileGenerationsIndex'
     | 'dataElementsIndex'
   >(metamodel, {
-    elementSectionMap: observable,
+    elementSectionIndex: observable,
     extensions: observable,
 
     sectionIndicesIndex: observable,

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

@@ -60,7 +60,6 @@ import {
   type ObserverContext,
   skipObservedWithContext,
   skipObserved,
-  observe_OptionalPackageableElementReference,
   observe_Multiplicity,
   observe_PackageableElementReference,
 } from './CoreObserverHelper.js';
@@ -511,7 +510,9 @@ function _observe_PropertyGraphFetchTree(
   metamodel.parameters.forEach((value) =>
     observe_ValueSpecification(value, context),
   );
-  observe_OptionalPackageableElementReference(metamodel.subType);
+  if (metamodel.subType) {
+    observe_PackageableElementReference(metamodel.subType);
+  }
 
   return metamodel;
 }

package/src/helpers/DSLMapping_Helper.ts

@@ -215,7 +215,7 @@ export const findPropertyMapping = (
   return properties.find(
     (propertyMapping) =>
       propertyMapping.targetSetImplementation &&
-      propertyMapping.targetSetImplementation.id.value === targetId,
+      propertyMapping.targetSetImplementation.value.id.value === targetId,
   );
 };
 

package/src/helpers/DomainHelper.ts

@@ -23,6 +23,7 @@ import {
   MILESTONING_STEREOTYPE,
   PRIMITIVE_TYPE,
   MULTIPLICITY_INFINITE,
+  PURE_DEPRECATED_STEREOTYPE,
 } from '../MetaModelConst.js';
 import { Package } from '../models/metamodels/pure/packageableElements/domain/Package.js';
 import type { PackageableElement } from '../models/metamodels/pure/packageableElements/PackageableElement.js';
@@ -59,6 +60,7 @@ import type { Enum } from '../models/metamodels/pure/packageableElements/domain/
 import type { Constraint } from '../models/metamodels/pure/packageableElements/domain/Constraint.js';
 import type { GenericType } from '../models/metamodels/pure/packageableElements/domain/GenericType.js';
 import type { Multiplicity } from '../models/metamodels/pure/packageableElements/domain/Multiplicity.js';
+import type { AnnotatedElement } from '../models/metamodels/pure/packageableElements/domain/AnnotatedElement.js';
 
 export const addElementToPackage = (
   parent: Package,
@@ -518,3 +520,15 @@ export const getMultiplicityDescription = (
       : `Must have at least ${multiplicity.lowerBound} values(s)`
   }`;
 };
+
+export const isElementDeprecated = (
+  element: AnnotatedElement | Class,
+  graph: PureModel,
+): boolean =>
+  element.stereotypes.some(
+    (st) =>
+      st.value ===
+      graph
+        .getProfile(CORE_PURE_PATH.PROFILE_DOC)
+        .p_stereotypes.find((s) => s.value === PURE_DEPRECATED_STEREOTYPE),
+  );