@finos/legend-graph 6.0.0 → 8.0.0

package/src/helpers/DomainHelper.ts

@@ -14,31 +14,51 @@
  * limitations under the License.
  */
 
-import type { PureModel } from '../graph/PureModel';
-import { Class } from '../models/metamodels/pure/packageableElements/domain/Class';
+import type { PureModel } from '../graph/PureModel.js';
+import { Class } from '../models/metamodels/pure/packageableElements/domain/Class.js';
 import {
   CORE_PURE_PATH,
   ELEMENT_PATH_DELIMITER,
   RESERVERD_PACKAGE_NAMES,
   MILESTONING_STEREOTYPE,
-} 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';
+  PRIMITIVE_TYPE,
+  MULTIPLICITY_INFINITE,
+} from '../MetaModelConst.js';
+import { Package } from '../models/metamodels/pure/packageableElements/domain/Package.js';
+import type { PackageableElement } from '../models/metamodels/pure/packageableElements/PackageableElement.js';
 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 { createPath } from '../MetaModelUtils.js';
+import type { BasicModel } from '../graph/BasicModel.js';
+import type { Profile } from '../models/metamodels/pure/packageableElements/domain/Profile.js';
+import type { Tag } from '../models/metamodels/pure/packageableElements/domain/Tag.js';
+import type { Stereotype } from '../models/metamodels/pure/packageableElements/domain/Stereotype.js';
+import type { Type } from '../models/metamodels/pure/packageableElements/domain/Type.js';
+import {
+  Measure,
+  Unit,
+} from '../models/metamodels/pure/packageableElements/domain/Measure.js';
+import { Enumeration } from '../models/metamodels/pure/packageableElements/domain/Enumeration.js';
+import { PrimitiveType } from '../models/metamodels/pure/packageableElements/domain/PrimitiveType.js';
+import { Property } from '../models/metamodels/pure/packageableElements/domain/Property.js';
+import type { Association } from '../models/metamodels/pure/packageableElements/domain/Association.js';
+import type {
+  AbstractProperty,
+  PropertyOwner,
+} from '../models/metamodels/pure/packageableElements/domain/AbstractProperty.js';
+import { DerivedProperty } from '../models/metamodels/pure/packageableElements/domain/DerivedProperty.js';
+import type { Enum } from '../models/metamodels/pure/packageableElements/domain/Enum.js';
+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';
 
 export const addElementToPackage = (
   parent: Package,
@@ -108,7 +128,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 +154,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 +165,7 @@ export const getOrCreatePackage = (
     let immediateParentPackageRelativePath = relativePackagePath;
     while (immediateParentPackageRelativePath !== '') {
       const fullPath = createPath(
-        parentPackage.fullPath,
+        parentPackage.path,
         immediateParentPackageRelativePath,
       );
       const cachedParentPackage = cache.get(fullPath);
@@ -188,15 +208,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 +253,268 @@ export const getMilestoneTemporalStereotype = (
   });
   return stereotype;
 };
+
+export const getTag = (profile: Profile, value: string): Tag =>
+  guaranteeNonNullable(
+    profile.p_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.p_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;
+};
+
+export const getMultiplicityDescription = (
+  multiplicity: Multiplicity,
+): string => {
+  if (multiplicity.lowerBound === multiplicity.upperBound) {
+    return `[${multiplicity.lowerBound.toString()}] - Must have exactly ${multiplicity.lowerBound.toString()} value(s)`;
+  } else if (
+    multiplicity.lowerBound === 0 &&
+    multiplicity.upperBound === undefined
+  ) {
+    return `[${MULTIPLICITY_INFINITE}] - May have many values`;
+  }
+  return `[${multiplicity.lowerBound}..${
+    multiplicity.upperBound ?? MULTIPLICITY_INFINITE
+  }] - ${
+    multiplicity.upperBound
+      ? `Must have from ${multiplicity.lowerBound} to ${multiplicity.upperBound} value(s)`
+      : `Must have at least ${multiplicity.lowerBound} values(s)`
+  }`;
+};

package/src/helpers/PureLanguageHelper.ts

@@ -14,12 +14,16 @@
  * limitations under the License.
  */
 
-import { 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';
-import { Enumeration } from '../models/metamodels/pure/packageableElements/domain/Enumeration';
-import format from 'date-fns/format';
+import {
+  MULTIPLICITY_INFINITE,
+  MULTIPLICITY_RANGE_OPERATOR,
+  PRIMITIVE_TYPE,
+} from '../MetaModelConst.js';
+import type { ConcreteFunctionDefinition } from '../models/metamodels/pure/packageableElements/domain/ConcreteFunctionDefinition.js';
+import type { Type } from '../models/metamodels/pure/packageableElements/domain/Type.js';
+import { PrimitiveType } from '../models/metamodels/pure/packageableElements/domain/PrimitiveType.js';
+import { Enumeration } from '../models/metamodels/pure/packageableElements/domain/Enumeration.js';
+import { format } from 'date-fns';
 
 export enum PURE_ELEMENT_NAME {
   PROFILE = 'Profile',
@@ -56,10 +60,24 @@ export enum PURE_PARSER {
   FLATDATA = 'FlatData',
   RELATIONAL = 'Relational',
   GENERATION_SPECIFICATION = 'GenerationSpecification',
-  FILE_GENERATION = 'FileGeneration',
+  FILE_GENERATION_SPECIFICATION = 'FileGeneration',
   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.js';
+import type { RootFlatDataRecordType } from '../models/metamodels/pure/packageableElements/store/flatData/model/FlatDataDataType.js';
+import type { FlatDataSection } from '../models/metamodels/pure/packageableElements/store/flatData/model/FlatDataSection.js';
+
+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] : [],
+  );

package/src/helpers/StoreRelational_Helper.ts

@@ -0,0 +1,161 @@
+/**
+ * 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 {
+  filterByType,
+  guaranteeNonNullable,
+  guaranteeType,
+  UnsupportedOperationError,
+} from '@finos/legend-shared';
+import { RelationalInputType } from '../models/metamodels/pure/packageableElements/store/relational/mapping/RelationalInputData.js';
+import { Column } from '../models/metamodels/pure/packageableElements/store/relational/model/Column.js';
+import { Database } from '../models/metamodels/pure/packageableElements/store/relational/model/Database.js';
+import type { Filter } from '../models/metamodels/pure/packageableElements/store/relational/model/Filter.js';
+import type { Join } from '../models/metamodels/pure/packageableElements/store/relational/model/Join.js';
+import {
+  JoinType,
+  type Relation,
+} from '../models/metamodels/pure/packageableElements/store/relational/model/RelationalOperationElement.js';
+import type { Schema } from '../models/metamodels/pure/packageableElements/store/relational/model/Schema.js';
+import type { Table } from '../models/metamodels/pure/packageableElements/store/relational/model/Table.js';
+import type { View } from '../models/metamodels/pure/packageableElements/store/relational/model/View.js';
+
+const collectIncludedDatabases = (
+  results: Set<Database>,
+  databases: Database[],
+): void => {
+  databases.forEach((i) => {
+    const includedDb = guaranteeType(i, Database);
+    if (!results.has(includedDb)) {
+      results.add(includedDb);
+      collectIncludedDatabases(
+        results,
+        includedDb.includes.map((s) => guaranteeType(s.value, Database)),
+      );
+    }
+  });
+};
+
+export const getAllIncludedDatabases = (db: Database): Set<Database> => {
+  const includes = db.includes;
+  const results = new Set<Database>();
+  results.add(db);
+  if (!includes.length) {
+    return results;
+  }
+  collectIncludedDatabases(
+    results,
+    db.includes.map((includedStore) =>
+      guaranteeType(includedStore.value, Database),
+    ),
+  );
+  return results;
+};
+
+export const getJoinType = (type: string): JoinType => {
+  switch (type) {
+    case JoinType.INNER:
+      return JoinType.INNER;
+    case JoinType.LEFT_OUTER:
+      return JoinType.LEFT_OUTER;
+    case JoinType.RIGHT_OUTER:
+      return JoinType.RIGHT_OUTER;
+    default:
+      throw new UnsupportedOperationError(
+        `Encountered unsupported join type '${type}'`,
+      );
+  }
+};
+
+export const getRelationalInputType = (type: string): RelationalInputType => {
+  switch (type) {
+    case RelationalInputType.SQL:
+      return RelationalInputType.SQL;
+    case RelationalInputType.CSV:
+      return RelationalInputType.CSV;
+    default:
+      throw new UnsupportedOperationError(
+        `Encountered unsupported relational input type '${type}'`,
+      );
+  }
+};
+
+export const getNullableSchema = (
+  database: Database,
+  name: string,
+): Schema | undefined =>
+  database.schemas.find((schema) => schema.name === name);
+
+export const getNullableFilter = (
+  database: Database,
+  name: string,
+): Filter | undefined =>
+  Array.from(getAllIncludedDatabases(database))
+    .flatMap((includedDB) => includedDB.filters)
+    .find((filter) => filter.name === name);
+
+export const getSchema = (database: Database, name: string): Schema =>
+  guaranteeNonNullable(
+    getNullableSchema(database, name),
+    `Can't find schema '${name}' in database '${database.path}'`,
+  );
+
+export const getJoin = (database: Database, name: string): Join =>
+  guaranteeNonNullable(
+    Array.from(getAllIncludedDatabases(database))
+      .flatMap((includedDB) => includedDB.joins)
+      .find((join) => join.name === name),
+    `Can't find join '${name}' in database '${database.path}'`,
+  );
+
+export const getFilter = (database: Database, name: string): Filter =>
+  guaranteeNonNullable(
+    getNullableFilter(database, name),
+    `Can't find filter '${name}' in database '${database.path}'`,
+  );
+
+export const getNullableTable = (
+  schema: Schema,
+  name: string,
+): Table | undefined => schema.tables.find((table) => table.name === name);
+
+export const getTable = (schema: Schema, name: string): Table =>
+  guaranteeNonNullable(
+    getNullableTable(schema, name),
+    `Can't find table '${name}' in schema '${schema.name}' of database '${schema._OWNER.path}'`,
+  );
+
+export const getView = (schema: Schema, name: string): View =>
+  guaranteeNonNullable(
+    schema.views.find((view) => view.name === name),
+    `Can't find view '${name}' in schema '${schema.name}' of database '${schema._OWNER.path}'`,
+  );
+
+export const getRelation = (schema: Schema, name: string): Relation => {
+  const relations: (Table | View)[] = schema.tables;
+  return guaranteeNonNullable(
+    relations.concat(schema.views).find((relation) => relation.name === name),
+    `Can't find relation '${name}' in schema '${schema.name}' of database '${schema._OWNER.path}'`,
+  );
+};
+
+export const getColumn = (relation: Table | View, name: string): Column =>
+  guaranteeNonNullable(
+    relation.columns
+      .filter(filterByType(Column))
+      .find((column) => column.name === name),
+    `Can't find column '${name}' in table '${relation.name}'`,
+  );