@finos/legend-graph 6.0.1 → 7.0.0

package/src/helpers/{MappingHelper.ts → DSLMapping_Helper.ts}

@@ -15,10 +15,13 @@
  */
 
 import {
+  assertTrue,
   filterByType,
   findLast,
+  generateEnumerableNameFromToken,
   guaranteeNonNullable,
   uniq,
+  UnsupportedOperationError,
 } from '@finos/legend-shared';
 import type { EnumerationMapping } from '../models/metamodels/pure/packageableElements/mapping/EnumerationMapping';
 import type { SetImplementation } from '../models/metamodels/pure/packageableElements/mapping/SetImplementation';
@@ -27,11 +30,42 @@ import type { Enumeration } from '../models/metamodels/pure/packageableElements/
 import type { Mapping } from '../models/metamodels/pure/packageableElements/mapping/Mapping';
 import { AggregationAwareSetImplementation } from '../models/metamodels/pure/packageableElements/mapping/aggregationAware/AggregationAwareSetImplementation';
 import { RootRelationalInstanceSetImplementation } from '../models/metamodels/pure/packageableElements/store/relational/mapping/RootRelationalInstanceSetImplementation';
+import type { PropertyMapping } from '../models/metamodels/pure/packageableElements/mapping/PropertyMapping';
+import type { InstanceSetImplementation } from '../models/metamodels/pure/packageableElements/mapping/InstanceSetImplementation';
+import type {
+  EngineRuntime,
+  IdentifiedConnection,
+} from '../models/metamodels/pure/packageableElements/runtime/Runtime';
+import { OperationSetImplementation } from '../models/metamodels/pure/packageableElements/mapping/OperationSetImplementation';
+import { ObjectInputType } from '../models/metamodels/pure/packageableElements/store/modelToModel/mapping/ObjectInputData';
+
+// ----------------------------------------- Mapping -----------------------------------------
+
+/**
+ * Get all included mappings, accounted for loop and duplication (which should be caught by compiler)
+ */
+export const getAllIncludedMappings = (mapping: Mapping): Mapping[] => {
+  const visited = new Set<Mapping>();
+  visited.add(mapping);
+  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(mapping);
+  visited.delete(mapping);
+  return Array.from(visited);
+};
 
 export const getAllClassMappings = (mapping: Mapping): SetImplementation[] =>
   uniq(
-    mapping.allOwnClassMappings.concat(
-      mapping.allIncludedMappings.map((e) => e.allOwnClassMappings).flat(),
+    mapping.classMappings.concat(
+      getAllIncludedMappings(mapping)
+        .map((e) => e.classMappings)
+        .flat(),
     ),
   );
 
@@ -39,9 +73,9 @@ export const getAllEnumerationMappings = (
   mapping: Mapping,
 ): EnumerationMapping[] =>
   uniq(
-    mapping.allOwnEnumerationMappings.concat(
-      mapping.allIncludedMappings
-        .map((e) => e.allOwnEnumerationMappings)
+    mapping.enumerationMappings.concat(
+      getAllIncludedMappings(mapping)
+        .map((e) => e.enumerationMappings)
         .flat(),
     ),
   );
@@ -72,7 +106,7 @@ export const getOwnClassMappingById = (
 ): SetImplementation =>
   guaranteeNonNullable(
     [
-      ...mapping.allOwnClassMappings,
+      ...mapping.classMappings,
       ...extractClassMappingsFromAggregationAwareClassMappings(mapping),
     ].find((classMapping) => classMapping.id.value === id),
     `Can't find class mapping with ID '${id}' in mapping '${mapping.path}'`,
@@ -96,7 +130,7 @@ export const getOwnClassMappingsByClass = (
 ): SetImplementation[] =>
   // TODO: Add association property Mapping to class mappings, AggregationAwareSetImplementation, mappingClass
   // NOTE: Add in the proper order so find root can resolve properly down the line
-  mapping.allOwnClassMappings.filter(
+  mapping.classMappings.filter(
     (classMapping) => classMapping.class.value === _class,
   );
 
@@ -128,7 +162,7 @@ export const getAllSuperSetImplementations = (
   ) {
     const superSetImpl = [
       getClassMappingById(
-        currentSetImpl.parent,
+        currentSetImpl._PARENT,
         currentSetImpl.superSetImplementationId,
       ),
     ];
@@ -165,3 +199,102 @@ export const getRootSetImplementation = (
   _class: Class,
 ): SetImplementation | undefined =>
   findRootSetImplementation(getClassMappingsByClass(mapping, _class));
+
+export const findPropertyMapping = (
+  instanceSetImplementation: InstanceSetImplementation,
+  propertyName: string,
+  targetId: string | undefined,
+): PropertyMapping | undefined => {
+  let properties = undefined;
+  properties = instanceSetImplementation.propertyMappings.filter(
+    (propertyMapping) => propertyMapping.property.value.name === propertyName,
+  );
+  if (targetId === undefined || properties.length === 1) {
+    return properties[0];
+  }
+  return properties.find(
+    (propertyMapping) =>
+      propertyMapping.targetSetImplementation &&
+      propertyMapping.targetSetImplementation.id.value === targetId,
+  );
+};
+
+/**
+ * Get all child set implementation of an operation set implementation (including itself).
+ * This takes into account loops and duplication.
+ */
+export const getAllChildSetImplementations = (
+  operationSetImplementation: OperationSetImplementation,
+): SetImplementation[] => {
+  const visitedOperations = new Set<OperationSetImplementation>();
+  visitedOperations.add(operationSetImplementation);
+  const _leaves = new Set<SetImplementation>();
+  const resolveLeaves = (_opSetImpl: OperationSetImplementation): void => {
+    _opSetImpl.parameters.forEach((p) => {
+      const setImp = p.setImplementation.value;
+      if (
+        setImp instanceof OperationSetImplementation &&
+        !visitedOperations.has(setImp)
+      ) {
+        visitedOperations.add(setImp);
+        resolveLeaves(setImp);
+      } else {
+        _leaves.add(setImp);
+      }
+    });
+  };
+  resolveLeaves(operationSetImplementation);
+  visitedOperations.delete(operationSetImplementation);
+  return Array.from(_leaves).concat(Array.from(visitedOperations));
+};
+
+/**
+ * Get all leaf set implementations (i.e. no operation) of an operation set implementation
+ * This takes into account loops and duplication.
+ */
+export const getLeafSetImplementations = (
+  operationSetImplementation: OperationSetImplementation,
+): SetImplementation[] =>
+  getAllChildSetImplementations(operationSetImplementation).filter(
+    (child) => !(child instanceof OperationSetImplementation),
+  );
+
+export const getObjectInputType = (type: string): ObjectInputType => {
+  switch (type) {
+    case ObjectInputType.JSON:
+      return ObjectInputType.JSON;
+    case ObjectInputType.XML:
+      return ObjectInputType.XML;
+    default:
+      throw new UnsupportedOperationError(
+        `Encountered unsupported object input type '${type}'`,
+      );
+  }
+};
+
+// ----------------------------------------- Runtime -----------------------------------------
+
+export const getAllIdentifiedConnections = (
+  runtime: EngineRuntime,
+): IdentifiedConnection[] =>
+  runtime.connections.flatMap(
+    (storeConnections) => storeConnections.storeConnections,
+  );
+
+export const generateIdentifiedConnectionId = (
+  runtime: EngineRuntime,
+): string => {
+  const generatedId = generateEnumerableNameFromToken(
+    getAllIdentifiedConnections(runtime).map(
+      (identifiedConnection) => identifiedConnection.id,
+    ),
+    'connection',
+  );
+  assertTrue(
+    !getAllIdentifiedConnections(runtime).find(
+      (identifiedConnection) => identifiedConnection.id === generatedId,
+    ),
+    `Can't auto-generate connection ID with value '${generatedId}'`,
+  );
+  return generatedId;
+};

package/src/helpers/{ServiceHelper.ts → DSLService_Helper.ts}

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 import { addUniqueEntry } from '@finos/legend-shared';
 import {
   type ValidationIssue,

package/src/helpers/DomainHelper.ts

@@ -21,24 +21,42 @@ import {
   ELEMENT_PATH_DELIMITER,
   RESERVERD_PACKAGE_NAMES,
   MILESTONING_STEREOTYPE,
+  PRIMITIVE_TYPE,
 } from '../MetaModelConst';
-import { Profile } from '../models/metamodels/pure/packageableElements/domain/Profile';
-import { Tag } from '../models/metamodels/pure/packageableElements/domain/Tag';
-import { Enum } from '../models/metamodels/pure/packageableElements/domain/Enum';
-import { Stereotype } from '../models/metamodels/pure/packageableElements/domain/Stereotype';
-import { TaggedValue } from '../models/metamodels/pure/packageableElements/domain/TaggedValue';
-import { TagExplicitReference } from '../models/metamodels/pure/packageableElements/domain/TagReference';
-import type { Enumeration } from '../models/metamodels/pure/packageableElements/domain/Enumeration';
 import { Package } from '../models/metamodels/pure/packageableElements/domain/Package';
 import type { PackageableElement } from '../models/metamodels/pure/packageableElements/PackageableElement';
 import {
+  type Clazz,
   AssertionError,
   assertNonEmptyString,
   assertTrue,
+  guaranteeNonNullable,
   guaranteeType,
+  uniqBy,
+  UnsupportedOperationError,
 } from '@finos/legend-shared';
 import { createPath } from '../MetaModelUtils';
 import type { BasicModel } from '../graph/BasicModel';
+import type { Profile } from '../models/metamodels/pure/packageableElements/domain/Profile';
+import type { Tag } from '../models/metamodels/pure/packageableElements/domain/Tag';
+import type { Stereotype } from '../models/metamodels/pure/packageableElements/domain/Stereotype';
+import type { Type } from '../models/metamodels/pure/packageableElements/domain/Type';
+import {
+  Measure,
+  Unit,
+} from '../models/metamodels/pure/packageableElements/domain/Measure';
+import { Enumeration } from '../models/metamodels/pure/packageableElements/domain/Enumeration';
+import { PrimitiveType } from '../models/metamodels/pure/packageableElements/domain/PrimitiveType';
+import { Property } from '../models/metamodels/pure/packageableElements/domain/Property';
+import type { Association } from '../models/metamodels/pure/packageableElements/domain/Association';
+import type {
+  AbstractProperty,
+  PropertyOwner,
+} from '../models/metamodels/pure/packageableElements/domain/AbstractProperty';
+import { DerivedProperty } from '../models/metamodels/pure/packageableElements/domain/DerivedProperty';
+import type { Enum } from '../models/metamodels/pure/packageableElements/domain/Enum';
+import type { Constraint } from '../models/metamodels/pure/packageableElements/domain/Constraint';
+import type { GenericType } from '../models/metamodels/pure/packageableElements/domain/GenericType';
 
 export const addElementToPackage = (
   parent: Package,
@@ -108,7 +126,7 @@ const _getOrCreatePackage = (
 
   // populate cache after resolving the package
   if (cache) {
-    cache.set(createPath(parentPackage.fullPath, packageName), pkg);
+    cache.set(createPath(parentPackage.path, packageName), pkg);
   }
 
   // traverse the package chain
@@ -134,7 +152,7 @@ export const getOrCreatePackage = (
   if (cache) {
     // short-circuit
     const cachedPackage = cache.get(
-      createPath(parentPackage.fullPath, relativePackagePath),
+      createPath(parentPackage.path, relativePackagePath),
     );
     if (cachedPackage) {
       return cachedPackage;
@@ -145,7 +163,7 @@ export const getOrCreatePackage = (
     let immediateParentPackageRelativePath = relativePackagePath;
     while (immediateParentPackageRelativePath !== '') {
       const fullPath = createPath(
-        parentPackage.fullPath,
+        parentPackage.path,
         immediateParentPackageRelativePath,
       );
       const cachedParentPackage = cache.get(fullPath);
@@ -188,15 +206,20 @@ export const getOrCreateGraphPackage = (
   return getOrCreatePackage(graph.root, packagePath, true, cache);
 };
 
-export const createStubTag = (profile: Profile): Tag => new Tag(profile, '');
-export const createStubTaggedValue = (tag: Tag): TaggedValue =>
-  new TaggedValue(TagExplicitReference.create(tag), '');
-export const createStubStereotype = (profile: Profile): Stereotype =>
-  new Stereotype(profile, '');
-export const createStubProfile = (): Profile => new Profile('');
-export const createStubEnum = (enumeration: Enumeration): Enum =>
-  new Enum('', enumeration);
+export const getRawGenericType = <T extends Type>(
+  genericType: GenericType,
+  clazz: Clazz<T>,
+): T => guaranteeType<T>(genericType.rawType, clazz);
 
+/**
+ * Extract the type of temporal milestone the class is associated with (using stereotype).
+ *
+ * Whatever the type, it means the class is milestoned, which means:
+ * 1. properties of this type will now be considered milestoned, and will be automatically
+ *    converted into a derived property which accept some temporal parameters (depending
+ *    on the milestoning type)
+ * 2. when we query properties of this type, we can provide the values for these parameters
+ */
 export const getMilestoneTemporalStereotype = (
   val: Class,
   graph: PureModel,
@@ -228,3 +251,248 @@ export const getMilestoneTemporalStereotype = (
   });
   return stereotype;
 };
+
+export const getTag = (profile: Profile, value: string): Tag =>
+  guaranteeNonNullable(
+    profile.tags.find((tag) => tag.value === value),
+    `Can't find tag '${value}' in profile '${profile.path}'`,
+  );
+
+export const getStereotype = (profile: Profile, value: string): Stereotype =>
+  guaranteeNonNullable(
+    profile.stereotypes.find((stereotype) => stereotype.value === value),
+    `Can't find stereotype '${value}' in profile '${profile.path}'`,
+  );
+
+export const getEnumValueNames = (enumeration: Enumeration): string[] =>
+  enumeration.values.map((value) => value.name).filter(Boolean);
+
+export const getEnumValue = (enumeration: Enumeration, name: string): Enum =>
+  guaranteeNonNullable(
+    enumeration.values.find((value) => value.name === name),
+    `Can't find enum value '${name}' in enumeration '${enumeration.path}'`,
+  );
+
+export const getFirstAssociatedProperty = (
+  association: Association,
+): Property => guaranteeNonNullable(association.properties[0]);
+
+export const getSecondAssociatedProperty = (
+  association: Association,
+): Property => guaranteeNonNullable(association.properties[1]);
+
+export const getOtherAssociatedProperty = (
+  association: Association,
+  property: Property,
+): Property => {
+  const idx = association.properties.findIndex((p) => p === property);
+  assertTrue(
+    idx !== -1,
+    `Can't find property '${property.name}' in association '${association.path}'`,
+  );
+  return guaranteeNonNullable(association.properties[(idx + 1) % 2]);
+};
+
+export const getAssociatedPropertyClass = (
+  association: Association,
+  property: AbstractProperty,
+): Class => {
+  if (property instanceof Property) {
+    return guaranteeType(
+      getOtherAssociatedProperty(association, property).genericType
+        .ownerReference.value,
+      Class,
+      `Association property '${property.name}' must be of type 'class'`,
+    );
+  } else if (property instanceof DerivedProperty) {
+    throw new UnsupportedOperationError(
+      `Derived property is not currently supported in association`,
+    );
+  }
+  throw new UnsupportedOperationError(
+    `Can't get associated class of property`,
+    property,
+  );
+};
+
+export const getOwnProperty = (
+  propertyOwner: PropertyOwner,
+  name: string,
+): Property =>
+  guaranteeNonNullable(
+    propertyOwner.properties.find((property) => property.name === name),
+    `Can't find property '${name}' in owner '${propertyOwner.path}'`,
+  );
+
+/**
+ * Get all super types of a class, accounted for loop and duplication (which should be caught by compiler)
+ * NOTE: we intentionally leave out `Any`
+ */
+export const getAllSuperclasses = (c: Class): Class[] => {
+  const visitedClasses = new Set<Class>();
+  visitedClasses.add(c);
+  const resolveSuperTypes = (_class: Class): void => {
+    _class.generalizations.forEach((gen) => {
+      const superType = getRawGenericType(gen.value, Class);
+      if (!visitedClasses.has(superType)) {
+        visitedClasses.add(superType);
+        resolveSuperTypes(superType);
+      }
+    });
+  };
+  resolveSuperTypes(c);
+  visitedClasses.delete(c);
+  return Array.from(visitedClasses);
+};
+
+/**
+ * Get all subclasses of a class, accounted for loop and duplication (which should be caught by compiler)
+ * NOTE: we intentionally leave out `Any`
+ */
+export const getAllSubclasses = (c: Class): Class[] => {
+  const visitedClasses = new Set<Class>();
+  visitedClasses.add(c);
+  const resolveSubclasses = (_class: Class): void => {
+    _class._subclasses.forEach((subclass) => {
+      if (!visitedClasses.has(subclass)) {
+        visitedClasses.add(subclass);
+        resolveSubclasses(subclass);
+      }
+    });
+  };
+  resolveSubclasses(c);
+  visitedClasses.delete(c);
+  return Array.from(visitedClasses);
+};
+
+/**
+ * Get class and its supertypes' properties recursively, duplications and loops are handled (Which should be caught by compiler)
+ */
+export const getAllClassProperties = (_class: Class): Property[] =>
+  uniqBy(
+    getAllSuperclasses(_class)
+      .concat(_class)
+      .map((c) => c.propertiesFromAssociations.concat(c.properties))
+      .flat(),
+    (property) => property.name,
+  );
+
+export const getAllClassDerivedProperties = (
+  _class: Class,
+): DerivedProperty[] =>
+  uniqBy(
+    getAllSuperclasses(_class)
+      .concat(_class)
+      .map((c) => c.derivedProperties)
+      .flat(),
+    (property) => property.name,
+  );
+
+export const getClassProperty = (_class: Class, name: string): Property =>
+  guaranteeNonNullable(
+    getAllClassProperties(_class).find((property) => property.name === name),
+    `Can't find property '${name}' in class '${_class.path}'`,
+  );
+
+export const getAllOwnClassProperties = (_class: Class): AbstractProperty[] =>
+  _class.properties
+    .concat(_class.propertiesFromAssociations)
+    .concat(_class.derivedProperties);
+
+export const getOwnClassProperty = (
+  _class: Class,
+  name: string,
+): AbstractProperty =>
+  guaranteeNonNullable(
+    getAllOwnClassProperties(_class).find((property) => property.name === name),
+    `Can't find property '${name}' in class '${_class.path}'`,
+  );
+
+export const getAllClassConstraints = (_class: Class): Constraint[] =>
+  // Perhaps we don't need to care about deduping constraints here like for properties
+  getAllSuperclasses(_class)
+    .concat(_class)
+    .map((c) => c.constraints)
+    .flat();
+
+/**
+ * Check if the first type subtype of the second type
+ *
+ * NOTE: Use this 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
+ */
+export const isSubType = (type1: Type, type2: Type): boolean => {
+  if (type1 instanceof Unit) {
+    return type1.measure === type2;
+  } else if (type1 instanceof Measure) {
+    return false;
+  } else if (type1 instanceof Enumeration) {
+    return false;
+  } else if (type1 instanceof PrimitiveType) {
+    if (!(type2 instanceof PrimitiveType)) {
+      return false;
+    }
+    if (type2.name === PRIMITIVE_TYPE.NUMBER) {
+      return (
+        type1.name === PRIMITIVE_TYPE.INTEGER ||
+        type1.name === PRIMITIVE_TYPE.FLOAT ||
+        type1.name === PRIMITIVE_TYPE.DECIMAL
+      );
+    }
+    if (type2.name === PRIMITIVE_TYPE.DATE) {
+      return (
+        type1.name === PRIMITIVE_TYPE.STRICTDATE ||
+        type1.name === PRIMITIVE_TYPE.DATETIME ||
+        type1.name === PRIMITIVE_TYPE.LATESTDATE
+      );
+    }
+  } else if (type1 instanceof Class) {
+    return (
+      type1.path === CORE_PURE_PATH.ANY ||
+      (type2 instanceof Class && getAllSuperclasses(type2).includes(type1))
+    );
+  }
+  return false;
+};
+
+/**
+ * Check if the first type supertype of the second type
+ *
+ * NOTE: Use this 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
+ */
+export const isSuperType = (type1: Type, type2: Type): boolean => {
+  if (type1 instanceof Unit) {
+    return false;
+  } else if (type1 instanceof Measure) {
+    return type2 instanceof Unit && type2.measure === type1;
+  } else if (type1 instanceof Enumeration) {
+    return false;
+  } else if (type1 instanceof PrimitiveType) {
+    if (!(type2 instanceof PrimitiveType)) {
+      return false;
+    }
+    if (type1.name === PRIMITIVE_TYPE.NUMBER) {
+      return (
+        type2.name === PRIMITIVE_TYPE.INTEGER ||
+        type2.name === PRIMITIVE_TYPE.FLOAT ||
+        type2.name === PRIMITIVE_TYPE.DECIMAL
+      );
+    }
+    if (type1.name === PRIMITIVE_TYPE.DATE) {
+      return (
+        type2.name === PRIMITIVE_TYPE.STRICTDATE ||
+        type2.name === PRIMITIVE_TYPE.DATETIME ||
+        type2.name === PRIMITIVE_TYPE.LATESTDATE
+      );
+    }
+  } else if (type1 instanceof Class) {
+    return (
+      type2.path === CORE_PURE_PATH.ANY ||
+      (type2 instanceof Class && getAllSubclasses(type2).includes(type1))
+    );
+  }
+  return false;
+};

package/src/helpers/PureLanguageHelper.ts

@@ -14,7 +14,11 @@
  * limitations under the License.
  */
 
-import { PRIMITIVE_TYPE } from '../MetaModelConst';
+import {
+  MULTIPLICITY_INFINITE,
+  MULTIPLICITY_RANGE_OPERATOR,
+  PRIMITIVE_TYPE,
+} from '../MetaModelConst';
 import type { ConcreteFunctionDefinition } from '../models/metamodels/pure/packageableElements/domain/ConcreteFunctionDefinition';
 import type { Type } from '../models/metamodels/pure/packageableElements/domain/Type';
 import { PrimitiveType } from '../models/metamodels/pure/packageableElements/domain/PrimitiveType';
@@ -60,6 +64,20 @@ export enum PURE_PARSER {
   DATA = 'Data',
 }
 
+export const generateMultiplicityString = (
+  lowerBound: number,
+  upperBound: number | undefined,
+): string => {
+  if (lowerBound === upperBound) {
+    return lowerBound.toString();
+  } else if (lowerBound === 0 && upperBound === undefined) {
+    return MULTIPLICITY_INFINITE;
+  }
+  return `${lowerBound}${MULTIPLICITY_RANGE_OPERATOR}${
+    upperBound ?? MULTIPLICITY_INFINITE
+  }`;
+};
+
 export const generateDefaultParameterValueForType = (
   type: Type | undefined,
   index: number,
@@ -120,6 +138,15 @@ export const generateFunctionSignature = (
   fullPath: boolean,
 ): string =>
   `${fullPath ? element.path : element.name}(${element.parameters
-    .map((p) => `${p.name}: ${p.type.value.name}[${p.multiplicity.str}]`)
+    .map(
+      (p) =>
+        `${p.name}: ${p.type.value.name}[${generateMultiplicityString(
+          p.multiplicity.lowerBound,
+          p.multiplicity.upperBound,
+        )}]`,
+    )
     .join(', ')})` +
-  `: ${element.returnType.value.name}[${element.returnMultiplicity.str}]`;
+  `: ${element.returnType.value.name}[${generateMultiplicityString(
+    element.returnMultiplicity.lowerBound,
+    element.returnMultiplicity.upperBound,
+  )}]`;

package/src/helpers/StoreFlatData_Helper.ts

@@ -0,0 +1,41 @@
+/**
+ * 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 { guaranteeNonNullable } from '@finos/legend-shared';
+import type { FlatData } from '../models/metamodels/pure/packageableElements/store/flatData/model/FlatData';
+import type { RootFlatDataRecordType } from '../models/metamodels/pure/packageableElements/store/flatData/model/FlatDataDataType';
+import type { FlatDataSection } from '../models/metamodels/pure/packageableElements/store/flatData/model/FlatDataSection';
+
+export const getRootRecordType = (
+  section: FlatDataSection,
+): RootFlatDataRecordType =>
+  guaranteeNonNullable(
+    section.recordType,
+    `No record type defined in section '${section.name}' of flat-data store '${section._OWNER.path}'`,
+  );
+
+export const getSection = (flatData: FlatData, name: string): FlatDataSection =>
+  guaranteeNonNullable(
+    flatData.sections.find((section) => section.name === name),
+    `Can't find section '${name}' in flat-data store '${flatData.path}'`,
+  );
+
+export const getAllRecordTypes = (
+  flatData: FlatData,
+): RootFlatDataRecordType[] =>
+  flatData.sections.flatMap((section) =>
+    section.recordType ? [section.recordType] : [],
+  );