@finos/legend-graph 14.0.6 → 14.1.0

package/src/StoreRelational_Exports.ts

@@ -33,8 +33,15 @@ export {
   ColumnReference,
   ColumnExplicitReference,
 } from './graph/metamodel/pure/packageableElements/store/relational/model/ColumnReference.js';
-export { type Mapper } from './graph/metamodel/pure/packageableElements/store/relational/connection/postprocessor/Mapper.js';
+export {
+  TableNameMapper,
+  Mapper,
+  SchemaNameMapper,
+} from './graph/metamodel/pure/packageableElements/store/relational/connection/postprocessor/Mapper.js';
+
 export { PostProcessor } from './graph/metamodel/pure/packageableElements/store/relational/connection/postprocessor/PostProcessor.js';
+export { MapperPostProcessor } from './graph/metamodel/pure/packageableElements/store/relational/connection/postprocessor/MapperPostProcessor.js';
+
 export { Milestoning } from './graph/metamodel/pure/packageableElements/store/relational/model/milestoning/Milestoning.js';
 export * from './graph/metamodel/pure/packageableElements/store/relational/model/RelationalDataType.js';
 export * from './graph/metamodel/pure/packageableElements/store/relational/model/RelationalOperationElement.js';

package/src/graph/Core_HashUtils.ts

@@ -157,7 +157,7 @@ export enum CORE_HASH_STRUCTURE {
   OAUTH_AUTHENTICATION_STRATEGY = 'OAUTH_AUTHENTICATION_STRATEGY',
   GCP_WORKLOAD_IDENTITY_FEDERATION_AUTHENTICATION_STRATEGY = 'GCP_WORKLOAD_IDENTITY_FEDERATION_AUTHENTICATION_STRATEGY',
   MIDDLE_TIER_USERNAME_PASSWORD_AUTHENTICATION_STRATEGY = 'MIDDLE_TIER_USERNAME_PASSWORD_AUTHENTICATION_STRATEGY',
-  // relational database connection post processors
+  // relational database connection post-processors
   MAPPER_POST_PROCESSOR = 'MAPPER_POST_PROCESSOR',
   SCHEMA_MAPPER = 'SCHEMA_MAPPER',
   TABLE_MAPPER = 'TABLE_MAPPER',

package/src/graph/DependencyManager.ts

@@ -179,93 +179,65 @@ export class DependencyManager {
   }
 
   get sectionIndices(): SectionIndex[] {
-    return this.dependencyGraphs
-      .map((dep) => Array.from(dep.ownSectionIndices))
-      .flat();
+    return this.dependencyGraphs.flatMap((dep) => dep.ownSectionIndices);
   }
   get profiles(): Profile[] {
-    return this.dependencyGraphs
-      .map((dep) => Array.from(dep.ownProfiles))
-      .flat();
+    return this.dependencyGraphs.flatMap((dep) => dep.ownProfiles);
   }
   get enumerations(): Enumeration[] {
-    return this.dependencyGraphs
-      .map((dep) => Array.from(dep.ownEnumerations))
-      .flat();
+    return this.dependencyGraphs.flatMap((dep) => dep.ownEnumerations);
   }
   get measures(): Measure[] {
-    return this.dependencyGraphs
-      .map((dep) => Array.from(dep.ownMeasures))
-      .flat();
+    return this.dependencyGraphs.flatMap((dep) => dep.ownMeasures);
   }
   get classes(): Class[] {
-    return this.dependencyGraphs
-      .map((dep) => Array.from(dep.ownClasses))
-      .flat();
+    return this.dependencyGraphs.flatMap((dep) => dep.ownClasses);
   }
   get types(): Type[] {
-    return this.dependencyGraphs.map((dep) => Array.from(dep.ownTypes)).flat();
+    return this.dependencyGraphs.flatMap((dep) => dep.ownTypes);
   }
   get associations(): Association[] {
-    return this.dependencyGraphs
-      .map((dep) => Array.from(dep.ownAssociations))
-      .flat();
+    return this.dependencyGraphs.flatMap((dep) => dep.ownAssociations);
   }
   get functions(): ConcreteFunctionDefinition[] {
-    return this.dependencyGraphs
-      .map((dep) => Array.from(dep.ownFunctions))
-      .flat();
+    return this.dependencyGraphs.flatMap((dep) => dep.ownFunctions);
   }
   get stores(): Store[] {
-    return this.dependencyGraphs.map((dep) => Array.from(dep.ownStores)).flat();
+    return this.dependencyGraphs.flatMap((dep) => dep.ownStores);
   }
   get databases(): Database[] {
-    return this.dependencyGraphs
-      .map((dep) => Array.from(dep.ownDatabases))
-      .flat();
+    return this.dependencyGraphs.flatMap((dep) => dep.ownDatabases);
   }
   get mappings(): Mapping[] {
-    return this.dependencyGraphs
-      .map((dep) => Array.from(dep.ownMappings))
-      .flat();
+    return this.dependencyGraphs.flatMap((dep) => dep.ownMappings);
   }
   get services(): Service[] {
-    return this.dependencyGraphs
-      .map((dep) => Array.from(dep.ownServices))
-      .flat();
+    return this.dependencyGraphs.flatMap((dep) => dep.ownServices);
   }
   get runtimes(): PackageableRuntime[] {
-    return this.dependencyGraphs
-      .map((dep) => Array.from(dep.ownRuntimes))
-      .flat();
+    return this.dependencyGraphs.flatMap((dep) => dep.ownRuntimes);
   }
   get connections(): PackageableConnection[] {
-    return this.dependencyGraphs
-      .map((dep) => Array.from(dep.ownConnections))
-      .flat();
+    return this.dependencyGraphs.flatMap((dep) => dep.ownConnections);
   }
   get dataElements(): DataElement[] {
-    return this.dependencyGraphs
-      .map((dep) => Array.from(dep.ownDataElements))
-      .flat();
+    return this.dependencyGraphs.flatMap((dep) => dep.ownDataElements);
   }
   get generationSpecifications(): GenerationSpecification[] {
-    return this.dependencyGraphs
-      .map((dep) => Array.from(dep.ownGenerationSpecifications))
-      .flat();
+    return this.dependencyGraphs.flatMap(
+      (dep) => dep.ownGenerationSpecifications,
+    );
   }
   get fileGenerations(): FileGenerationSpecification[] {
-    return this.dependencyGraphs
-      .map((dep) => Array.from(dep.ownFileGenerations))
-      .flat();
+    return this.dependencyGraphs.flatMap((dep) => dep.ownFileGenerations);
   }
 
   getExtensionElements<T extends PackageableElement>(
     extensionElementClass: Clazz<T>,
   ): T[] {
-    return this.dependencyGraphs
-      .map((dep) => dep.getExtensionElements(extensionElementClass))
-      .flat();
+    return this.dependencyGraphs.flatMap((dep) =>
+      dep.getExtensionElements(extensionElementClass),
+    );
   }
 
   getModel(projectId: string): BasicModel {

package/src/graph/MetaModelConst.ts

@@ -125,6 +125,9 @@ export enum CORE_PURE_PATH {
   GENERATION_SPECIFICATION = 'meta::pure::generation::metamodel::GenerationSpecification',
   SECTION_INDEX = 'meta::pure::metamodel::section::SectionIndex',
   DATA_ELEMENT = 'meta::pure::data::DataElement',
+
+  // TDS
+  TDS_ROW = 'meta::pure::tds::TDSRow',
 }
 
 export const PURE_DEPRECATED_STEREOTYPE = 'deprecated';

package/src/graph/helpers/DSLMapping_Helper.ts

@@ -38,6 +38,7 @@ import type {
 } from '../metamodel/pure/packageableElements/runtime/Runtime.js';
 import { OperationSetImplementation } from '../metamodel/pure/packageableElements/mapping/OperationSetImplementation.js';
 import { ObjectInputType } from '../metamodel/pure/packageableElements/store/modelToModel/mapping/ObjectInputData.js';
+import type { PackageableRuntime } from '../../DSLMapping_Exports.js';
 
 // ----------------------------------------- Mapping -----------------------------------------
 
@@ -272,6 +273,32 @@ export const getObjectInputType = (type: string): ObjectInputType => {
   }
 };
 
+export const getMappingCompatibleClasses = (
+  mapping: Mapping,
+  classes: Class[],
+): Class[] => {
+  const mappedClasses = new Set<Class>();
+  getAllClassMappings(mapping).forEach((cm) =>
+    mappedClasses.add(cm.class.value),
+  );
+  return classes.filter((c) => mappedClasses.has(c));
+};
+
+export const getClassCompatibleMappings = (
+  _class: Class,
+  mappings: Mapping[],
+): Mapping[] => {
+  const mappingsWithClassMapped = mappings.filter((mapping) =>
+    mapping.classMappings.some((cm) => cm.class.value === _class),
+  );
+  const resolvedMappingIncludes = mappings.filter((mapping) =>
+    getAllIncludedMappings(mapping).some((e) =>
+      mappingsWithClassMapped.includes(e),
+    ),
+  );
+  return uniq([...mappingsWithClassMapped, ...resolvedMappingIncludes]);
+};
+
 // ----------------------------------------- Runtime -----------------------------------------
 
 export const getAllIdentifiedConnections = (
@@ -298,3 +325,18 @@ export const generateIdentifiedConnectionId = (
   );
   return generatedId;
 };
+
+export const getMappingCompatibleRuntimes = (
+  mapping: Mapping,
+  runtimes: PackageableRuntime[],
+): PackageableRuntime[] =>
+  // If the runtime claims to cover some mappings which include the specified mapping,
+  // then we deem the runtime to be compatible with the such mapping
+  runtimes.filter((runtime) =>
+    runtime.runtimeValue.mappings
+      .flatMap((mappingReference) => [
+        mappingReference.value,
+        ...getAllIncludedMappings(mappingReference.value),
+      ])
+      .includes(mapping),
+  );

package/src/graph/metamodel/pure/packageableElements/store/relational/connection/postprocessor/Mapper.ts

@@ -15,7 +15,7 @@
  */
 
 import { CORE_HASH_STRUCTURE } from '../../../../../../../../graph/Core_HashUtils.js';
-import { type Hashable, hashArray } from '@finos/legend-shared';
+import { type Hashable, hashArray, uuid } from '@finos/legend-shared';
 
 export class PostProcessorParameter {}
 
@@ -23,6 +23,8 @@ export abstract class Mapper
   extends PostProcessorParameter
   implements Hashable
 {
+  readonly _UUID = uuid();
+
   from: string;
   to: string;
 

package/src/graph/metamodel/pure/packageableElements/store/relational/connection/postprocessor/PostProcessor.ts

@@ -14,8 +14,10 @@
  * limitations under the License.
  */
 
-import type { Hashable } from '@finos/legend-shared';
+import { type Hashable, uuid } from '@finos/legend-shared';
 
 export abstract class PostProcessor implements Hashable {
+  readonly _UUID = uuid();
+
   abstract get hashCode(): string;
 }

package/src/graphManager/GraphManagerState.ts

@@ -15,7 +15,7 @@
  */
 
 import { type Log, ActionState, assertErrorThrown } from '@finos/legend-shared';
-import { action, makeObservable, observable } from 'mobx';
+import { action, computed, makeObservable, observable } from 'mobx';
 import { DependencyManager } from '../graph/DependencyManager.js';
 import {
   CoreModel,
@@ -36,6 +36,23 @@ import { EmbeddedFlatDataPropertyMapping } from '../graph/metamodel/pure/package
 import { EmbeddedRelationalInstanceSetImplementation } from '../graph/metamodel/pure/packageableElements/store/relational/mapping/EmbeddedRelationalInstanceSetImplementation.js';
 import { buildPureGraphManager } from '../graphManager/protocol/pure/PureGraphManagerBuilder.js';
 import type { AssociationImplementation } from '../graph/metamodel/pure/packageableElements/mapping/AssociationImplementation.js';
+import type { Profile } from '../graph/metamodel/pure/packageableElements/domain/Profile.js';
+import type { Enumeration } from '../graph/metamodel/pure/packageableElements/domain/Enumeration.js';
+import type { Measure } from '../graph/metamodel/pure/packageableElements/domain/Measure.js';
+import type { Class } from '../graph/metamodel/pure/packageableElements/domain/Class.js';
+import type { Association } from '../graph/metamodel/pure/packageableElements/domain/Association.js';
+import type { ConcreteFunctionDefinition } from '../graph/metamodel/pure/packageableElements/domain/ConcreteFunctionDefinition.js';
+import type { Store } from '../graph/metamodel/pure/packageableElements/store/Store.js';
+import type { Database } from '../graph/metamodel/pure/packageableElements/store/relational/model/Database.js';
+import type { Mapping } from '../graph/metamodel/pure/packageableElements/mapping/Mapping.js';
+import type { Service } from '../graph/metamodel/pure/packageableElements/service/Service.js';
+import type { PackageableRuntime } from '../graph/metamodel/pure/packageableElements/runtime/PackageableRuntime.js';
+import type { PackageableConnection } from '../graph/metamodel/pure/packageableElements/connection/PackageableConnection.js';
+import type { DataElement } from '../graph/metamodel/pure/packageableElements/data/DataElement.js';
+import type { FileGenerationSpecification } from '../graph/metamodel/pure/packageableElements/fileGeneration/FileGenerationSpecification.js';
+import type { GenerationSpecification } from '../graph/metamodel/pure/packageableElements/generationSpecification/GenerationSpecification.js';
+import { PRIMITIVE_TYPE } from '../graph/MetaModelConst.js';
+import type { Type } from '../graph/metamodel/pure/packageableElements/domain/Type.js';
 
 export class BasicGraphManagerState {
   pluginManager: GraphManagerPluginManager;
@@ -107,6 +124,26 @@ export class GraphManagerState extends BasicGraphManagerState {
 
     makeObservable(this, {
       graph: observable,
+
+      usableClassPropertyTypes: computed,
+
+      usableProfiles: computed,
+      usableEnumerations: computed,
+      usableMeasures: computed,
+      usableClasses: computed,
+      usableAssociations: computed,
+      usableFunctions: computed,
+      usableStores: computed,
+      usableDatabases: computed,
+      usableMappings: computed,
+      usableServices: computed,
+      usableRuntimes: computed,
+      usableConnections: computed,
+      usableDataElements: computed,
+      usableGenerationSpecifications: computed,
+      usableFileGenerations: computed,
+      usableElements: computed,
+
       resetGraph: action,
     });
 
@@ -187,4 +224,142 @@ export class GraphManagerState extends BasicGraphManagerState {
         ),
     );
   }
+
+  get usableClassPropertyTypes(): Type[] {
+    return [
+      ...this.graph.primitiveTypes.filter(
+        (type) => type.path !== PRIMITIVE_TYPE.LATESTDATE,
+      ),
+      ...this.graph.ownTypes,
+      ...this.collectExposedSystemElements(this.graph.systemModel.ownTypes),
+      ...this.graph.dependencyManager.types,
+    ];
+  }
+
+  get usableProfiles(): Profile[] {
+    return [
+      ...this.collectExposedSystemElements(this.graph.systemModel.ownProfiles),
+      ...this.graph.dependencyManager.profiles,
+      ...this.graph.ownProfiles,
+    ];
+  }
+  get usableEnumerations(): Enumeration[] {
+    return [
+      ...this.collectExposedSystemElements(
+        this.graph.systemModel.ownEnumerations,
+      ),
+      ...this.graph.dependencyManager.enumerations,
+      ...this.graph.ownEnumerations,
+    ];
+  }
+  get usableMeasures(): Measure[] {
+    return [
+      ...this.collectExposedSystemElements(this.graph.systemModel.ownMeasures),
+      ...this.graph.dependencyManager.measures,
+      ...this.graph.ownMeasures,
+    ];
+  }
+  get usableClasses(): Class[] {
+    return [
+      ...this.collectExposedSystemElements(this.graph.systemModel.ownClasses),
+      ...this.graph.dependencyManager.classes,
+      ...this.graph.ownClasses,
+    ];
+  }
+  get usableAssociations(): Association[] {
+    return [
+      ...this.collectExposedSystemElements(
+        this.graph.systemModel.ownAssociations,
+      ),
+      ...this.graph.dependencyManager.associations,
+      ...this.graph.ownAssociations,
+    ];
+  }
+  get usableFunctions(): ConcreteFunctionDefinition[] {
+    return [
+      ...this.collectExposedSystemElements(this.graph.systemModel.ownFunctions),
+      ...this.graph.dependencyManager.functions,
+      ...this.graph.ownFunctions,
+    ];
+  }
+  get usableStores(): Store[] {
+    return [
+      ...this.collectExposedSystemElements(this.graph.systemModel.ownStores),
+      ...this.graph.dependencyManager.stores,
+      ...this.graph.ownStores,
+    ];
+  }
+  get usableDatabases(): Database[] {
+    return [
+      ...this.collectExposedSystemElements(this.graph.systemModel.ownDatabases),
+      ...this.graph.dependencyManager.databases,
+      ...this.graph.ownDatabases,
+    ];
+  }
+  get usableMappings(): Mapping[] {
+    return [
+      ...this.collectExposedSystemElements(this.graph.systemModel.ownMappings),
+      ...this.graph.dependencyManager.mappings,
+      ...this.graph.ownMappings,
+    ];
+  }
+  get usableServices(): Service[] {
+    return [
+      ...this.collectExposedSystemElements(this.graph.systemModel.ownServices),
+      ...this.graph.dependencyManager.services,
+      ...this.graph.ownServices,
+    ];
+  }
+  get usableRuntimes(): PackageableRuntime[] {
+    return [
+      ...this.collectExposedSystemElements(this.graph.systemModel.ownRuntimes),
+      ...this.graph.dependencyManager.runtimes,
+      ...this.graph.ownRuntimes,
+    ];
+  }
+  get usableConnections(): PackageableConnection[] {
+    return [
+      ...this.collectExposedSystemElements(
+        this.graph.systemModel.ownConnections,
+      ),
+      ...this.graph.dependencyManager.connections,
+      ...this.graph.ownConnections,
+    ];
+  }
+  get usableDataElements(): DataElement[] {
+    return [
+      ...this.collectExposedSystemElements(
+        this.graph.systemModel.ownDataElements,
+      ),
+      ...this.graph.dependencyManager.dataElements,
+      ...this.graph.ownDataElements,
+    ];
+  }
+  get usableGenerationSpecifications(): GenerationSpecification[] {
+    return [
+      ...this.collectExposedSystemElements(
+        this.graph.systemModel.ownGenerationSpecifications,
+      ),
+      ...this.graph.dependencyManager.generationSpecifications,
+      ...this.graph.ownGenerationSpecifications,
+    ];
+  }
+  get usableFileGenerations(): FileGenerationSpecification[] {
+    return [
+      ...this.collectExposedSystemElements(
+        this.graph.systemModel.ownFileGenerations,
+      ),
+      ...this.graph.dependencyManager.fileGenerations,
+      ...this.graph.ownFileGenerations,
+    ];
+  }
+  get usableElements(): PackageableElement[] {
+    return [
+      ...this.collectExposedSystemElements(
+        this.graph.systemModel.allOwnElements,
+      ),
+      ...this.graph.dependencyManager.allOwnElements,
+      ...this.graph.ownMeasures,
+    ];
+  }
 }

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

@@ -103,6 +103,11 @@ import {
 } from '../../../graph/metamodel/pure/packageableElements/store/relational/model/TableReference.js';
 import type { View } from '../../../graph/metamodel/pure/packageableElements/store/relational/model/View.js';
 import { ViewReference } from '../../../graph/metamodel/pure/packageableElements/store/relational/model/ViewReference.js';
+import {
+  type Mapper,
+  SchemaNameMapper,
+  TableNameMapper,
+} from '../../../StoreRelational_Exports.js';
 import type { StoreRelational_PureGraphManagerPlugin_Extension } from '../../StoreRelational_PureGraphManagerPlugin_Extension.js';
 import {
   type ObserverContext,
@@ -998,13 +1003,69 @@ export const observe_AuthenticationStrategy = (
   return metamodel;
 };
 
+const observe_Abstract_Mapper = (metamodel: Mapper): void => {
+  makeObservable(metamodel, {
+    from: observable,
+    to: observable,
+    hashCode: computed,
+  });
+};
+
+export const observe_SchemaNameMapper = skipObserved(
+  (metamodel: SchemaNameMapper): SchemaNameMapper => {
+    observe_Abstract_Mapper(metamodel);
+
+    return metamodel;
+  },
+);
+
+export const observe_TableNameMapper = skipObserved(
+  (metamodel: TableNameMapper): TableNameMapper => {
+    observe_Abstract_Mapper(metamodel);
+
+    makeObservable(metamodel, {
+      schema: observable,
+    });
+    observe_SchemaNameMapper(metamodel.schema);
+    return metamodel;
+  },
+);
+
+export const observe_Mapper = (metamodel: Mapper): Mapper => {
+  if (metamodel instanceof SchemaNameMapper) {
+    return observe_SchemaNameMapper(metamodel);
+  } else if (metamodel instanceof TableNameMapper) {
+    return observe_TableNameMapper(metamodel);
+  }
+  return metamodel;
+};
+
+const observe_Abstract_PostProcessor = (metamodel: PostProcessor): void => {
+  makeObservable(metamodel, {
+    hashCode: computed,
+  });
+};
+
+const observe_MapperPostProcessor = (
+  metamodel: MapperPostProcessor,
+): MapperPostProcessor => {
+  observe_Abstract_PostProcessor(metamodel);
+
+  makeObservable(metamodel, {
+    mappers: observable,
+  });
+  metamodel.mappers.forEach((mapper) => {
+    observe_Mapper(mapper);
+  });
+  return metamodel;
+};
+
 export const observe_PostProcessor = (
   metamodel: PostProcessor,
   context: ObserverContext,
 ): PostProcessor => {
   if (metamodel instanceof MapperPostProcessor) {
-    // TODO
-    return metamodel;
+    return observe_MapperPostProcessor(metamodel);
   }
   const extraObservers = context.plugins.flatMap(
     (plugin) =>
@@ -1043,14 +1104,15 @@ export const observe_RelationalDatabaseConnection = skipObservedWithContext(
     makeObservable(metamodel, {
       datasourceSpecification: observable,
       authenticationStrategy: observable,
+      postProcessors: observable,
       hashCode: computed,
     });
 
     observe_DatasourceSpecification(metamodel.datasourceSpecification, context);
     observe_AuthenticationStrategy(metamodel.authenticationStrategy, context);
-    metamodel.postProcessors.forEach((postProcessor) =>
-      observe_PostProcessor(postProcessor, context),
-    );
+    metamodel.postProcessors.forEach((postProcessor) => {
+      observe_PostProcessor(postProcessor, context);
+    });
 
     return metamodel;
   },

package/src/graphManager/protocol/pure/v1/transformation/pureGraph/from/V1_PostProcessorTransformer.ts

@@ -86,9 +86,9 @@ export const V1_transformPostProcessor = (
       ).V1_getExtraConnectionPostProcessorTransformers?.() ?? [],
   );
   for (const transformer of extraConnectionPostProcessorTransformers) {
-    const postprocessorProtocol = transformer(postProcessor, context);
-    if (postprocessorProtocol) {
-      return postprocessorProtocol;
+    const postProcessorProtocol = transformer(postProcessor, context);
+    if (postProcessorProtocol) {
+      return postProcessorProtocol;
     }
   }
   throw new UnsupportedOperationError(

package/src/graphManager/protocol/pure/v1/transformation/pureGraph/to/helpers/V1_PostProcessorBuilderHelper.ts

@@ -61,9 +61,9 @@ export const V1_buildPostProcessor = (
       ).V1_getExtraConnectionPostProcessorBuilders?.() ?? [],
   );
   for (const builder of extraPostProcessorBuilders) {
-    const postprocessor = builder(protocol, context);
-    if (postprocessor) {
-      return postprocessor;
+    const postProcessor = builder(protocol, context);
+    if (postProcessor) {
+      return postProcessor;
     }
   }
   throw new UnsupportedOperationError(

package/src/graphManager/protocol/pure/v1/transformation/pureProtocol/serializationHelpers/V1_PostProcessorSerializationHelper.ts

@@ -113,9 +113,9 @@ export const V1_serializePostProcessor = (
       ).V1_getExtraConnectionPostProcessorProtocolSerializers?.() ?? [],
   );
   for (const serializer of extraPostprocessorProtocolSerializers) {
-    const postprocessorProtocolJson = serializer(value);
-    if (postprocessorProtocolJson) {
-      return postprocessorProtocolJson;
+    const postProcessorProtocolJson = serializer(value);
+    if (postProcessorProtocolJson) {
+      return postProcessorProtocolJson;
     }
   }
   throw new UnsupportedOperationError(
@@ -139,9 +139,9 @@ export const V1_deserializePostProcessor = (
           ).V1_getExtraConnectionPostProcessorProtocolDeserializers?.() ?? [],
       );
       for (const deserializer of extraPostprocessorProtocolDeserializers) {
-        const postprocessorProtocol = deserializer(value);
-        if (postprocessorProtocol) {
-          return postprocessorProtocol;
+        const postProcessorProtocol = deserializer(value);
+        if (postProcessorProtocol) {
+          return postProcessorProtocol;
         }
       }
       throw new UnsupportedOperationError(

package/src/index.ts

@@ -23,6 +23,8 @@ export * from './graph/metamodel/pure/packageableElements/PackageableElementRefe
 export * from './graph/metamodel/pure/packageableElements/mapping/SetImplementationReference.js';
 export { SectionIndex } from './graph/metamodel/pure/packageableElements/section/SectionIndex.js';
 
+export { createExplicitRelationReference } from './graph/metamodel/pure/packageableElements/store/relational/model/RelationReference.js';
+
 export { Multiplicity } from './graph/metamodel/pure/packageableElements/domain/Multiplicity.js';
 export { Type } from './graph/metamodel/pure/packageableElements/domain/Type.js';
 export { DataType } from './graph/metamodel/pure/packageableElements/domain/DataType.js';

package/tsconfig.json

@@ -21,7 +21,7 @@
     "noImplicitOverride": true,
     "noUncheckedIndexedAccess": true,
     "exactOptionalPropertyTypes": true,
-    "forceConsistentCasingInFileNames": false,
+    "forceConsistentCasingInFileNames": true,
     "outDir": "./lib",
     "tsBuildInfoFile": "./build/prod.tsbuildinfo",
     "rootDir": "./src",

package/tsconfig.package.json

@@ -21,7 +21,7 @@
     "noImplicitOverride": true,
     "noUncheckedIndexedAccess": true,
     "exactOptionalPropertyTypes": true,
-    "forceConsistentCasingInFileNames": false,
+    "forceConsistentCasingInFileNames": true,
     "outDir": "./lib",
     "tsBuildInfoFile": "./build/package.tsbuildinfo",
     "rootDir": "./"