@itwin/ecschema-editing 5.0.0-dev.90 → 5.0.0-dev.93

package/lib/esm/Validation/ECRules.js

@@ -0,0 +1,578 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Validation
+ */
+import { ECClassModifier, ECStringConstants, EntityClass, Mixin, PrimitiveType, primitiveTypeToString, RelationshipMultiplicity, SchemaGraph, SchemaItemType, StrengthDirection, strengthDirectionToString, } from "@itwin/ecschema-metadata";
+import { createClassDiagnosticClass, createCustomAttributeContainerDiagnosticClass, createPropertyDiagnosticClass, createRelationshipConstraintDiagnosticClass, createSchemaDiagnosticClass, createSchemaItemDiagnosticClass, } from "./Diagnostic";
+const ruleSetName = "ECObjects";
+function getCode(code) {
+    return `${ruleSetName}-${code}`;
+}
+/**
+ * The unique diagnostic codes for ECObjects rules.
+ *
+ * To provide meaning to code values, with anticipation
+ * of future rules for all current EC Types, the following
+ * value ranges should be used:
+ *
+ * - Schema:                    000-099
+ * - Class:                     100-199
+ * - Constant:                  200-299
+ * - CustomAttribute            300-399
+ * - CustomAttributeClass:      400-499
+ * - CustomAttributeContainer:  500-599
+ * - EntityClass:               600-699
+ * - Enumeration:               700-799
+ * - Format:                    800-899
+ * - InvertedUnit:              900-999
+ * - KindOfQuantity:            1000-1099
+ * - Mixin:                     1100-1199
+ * - Phenomenon:                1200-1299
+ * - Property:                  1300-1399
+ * - PropertyCategory:          1400-1499
+ * - RelationshipClass:         1500-1599
+ * - RelationshipConstraint:    1600-1699
+ * - StructClass:               1700-1799
+ * - Unit:                      1800-1899
+ * - UnitSystem:                1900-1999
+ * @beta
+ */
+/* eslint-disable @typescript-eslint/naming-convention */
+export const DiagnosticCodes = {
+    // Class Rule Codes (100-199)
+    BaseClassIsSealed: getCode(100),
+    BaseClassOfDifferentType: getCode(101),
+    // EC-102 has been deprecated. Leaving the code here to prevent re-use.
+    AbstractClassWithNonAbstractBase: getCode(102),
+    // CA Container Rule Codes (500-599)
+    CustomAttributeNotOfConcreteClass: getCode(500),
+    CustomAttributeSchemaMustBeReferenced: getCode(501),
+    CustomAttributeClassNotFound: getCode(502),
+    // Enumeration Rule Codes (700-799)
+    EnumerationTypeUnsupported: getCode(700),
+    // Mixin Rule Codes (1100-1199)
+    MixinAppliedToClassMustDeriveFromConstraint: getCode(1100),
+    // Property Rule Codes (1300-1399)
+    IncompatibleValueTypePropertyOverride: getCode(1300),
+    IncompatibleTypePropertyOverride: getCode(1301),
+    IncompatibleUnitPropertyOverride: getCode(1302),
+    // Relationship Rule Codes (1500-1599)
+    AbstractConstraintMustNarrowBaseConstraints: getCode(1500),
+    DerivedConstraintsMustNarrowBaseConstraints: getCode(1501),
+    ConstraintClassesDeriveFromAbstractConstraint: getCode(1502),
+    // Relationship Constraint Rule Codes (1600-1699)
+    AtLeastOneConstraintClassDefined: getCode(1600),
+    AbstractConstraintMustExistWithMultipleConstraints: getCode(1601),
+};
+/**
+ * The list of [[IDiagnostic]] implementation classes used by the EC rule implementations.
+ * @beta
+ */
+export const Diagnostics = {
+    /** EC-001: Required message parameters: schema name, referenced schema name */
+    SupplementalSchemasCannotBeReferenced: createSchemaDiagnosticClass(getCode(1), "Referenced schema '{1}' of schema '{0}' is a supplemental schema. Supplemental schemas are not allowed to be referenced."),
+    /** EC-002: Required message parameters: schema name, reference schema alias, first schema reference name, second schema reference name. */
+    SchemaRefAliasMustBeUnique: createSchemaDiagnosticClass(getCode(2), "Schema '{0}' has multiple schema references ({2}, {3}) with the same alias '{1}', which is not allowed."),
+    /** EC-003: Required message parameters: schema name, cycle text */
+    ReferenceCyclesNotAllowed: createSchemaDiagnosticClass(getCode(3), "Schema '{0}' has reference cycles: {1}"),
+    /** EC-100: Required message parameters: childClass.FullName, baseClass.FullName */
+    BaseClassIsSealed: createClassDiagnosticClass(DiagnosticCodes.BaseClassIsSealed, "Class '{0}' cannot derive from sealed base class '{1}'."),
+    /** EC-101: Required message parameters: childClass.FullName, baseClass.FullName, baseClass.schemaItemType */
+    BaseClassIsOfDifferentType: createClassDiagnosticClass(DiagnosticCodes.BaseClassOfDifferentType, "Class '{0}' cannot derive from base class '{1}' of type '{2}'."),
+    /** **DEPRECATED** EC-102: Required message parameters: childClass.FullName, baseClass.FullName */
+    AbstractClassWithNonAbstractBase: createClassDiagnosticClass(DiagnosticCodes.AbstractClassWithNonAbstractBase, "Abstract Class '{0}' cannot derive from base class '{1}' because it is not an abstract class."),
+    /** EC-500: Required message parameters: CustomAttribute container name and CustomAttributeClass name. */
+    CustomAttributeNotOfConcreteClass: createCustomAttributeContainerDiagnosticClass(DiagnosticCodes.CustomAttributeNotOfConcreteClass, "The CustomAttribute container '{0}' has a CustomAttribute with the class '{1}' which is not a concrete class."),
+    /** EC-501: Required message parameters: CustomAttribute container name, CustomAttributeClass name, CustomAttributeClass Schema name. */
+    CustomAttributeSchemaMustBeReferenced: createCustomAttributeContainerDiagnosticClass(DiagnosticCodes.CustomAttributeSchemaMustBeReferenced, "The CustomAttribute container '{0}' has a CustomAttribute with the class '{1}' whose schema is not referenced by the container's Schema."),
+    /** EC-502: Required message parameters: CustomAttribute container name and CustomAttributeClass name. */
+    CustomAttributeClassNotFound: createCustomAttributeContainerDiagnosticClass(DiagnosticCodes.CustomAttributeClassNotFound, "The CustomAttribute container '{0}' has a CustomAttribute with the class '{1}' which cannot be found."),
+    /** EC-700: Required message parameters: Enumeration name */
+    EnumerationTypeUnsupported: createSchemaItemDiagnosticClass(DiagnosticCodes.EnumerationTypeUnsupported, "Enumeration '{0}' has invalid primitive type."),
+    /** EC-1100: Required message parameters: mixin class fullName, class fullName, applies to constraint class fullName */
+    MixinAppliedToClassMustDeriveFromConstraint: createSchemaItemDiagnosticClass(DiagnosticCodes.MixinAppliedToClassMustDeriveFromConstraint, "Mixin '{0}' cannot be applied to the class '{1}' because it does not satisfy the applies to constraint '{2}'."),
+    /** EC-1300: Required message parameters: childClass.FullName, property name, baseClass.FullName, base value type, child value type */
+    IncompatibleValueTypePropertyOverride: createPropertyDiagnosticClass(DiagnosticCodes.IncompatibleValueTypePropertyOverride, "The ECProperty '{0}.{1}' has a base property '{2}.{1}' with a value type of {3} which is incompatible with the value type of {4}."),
+    /** EC-1301: Required message parameters: childClass.FullName, property name, baseClass.FullName, base property type, child property type */
+    IncompatibleTypePropertyOverride: createPropertyDiagnosticClass(DiagnosticCodes.IncompatibleTypePropertyOverride, "The ECProperty '{0}.{1}' has a base property '{2}.{1}' with a type of {3} which is incompatible with the type of {4}."),
+    /** EC-1302: Required message parameters: childClass.Name, property name, baseClass.Name, baseClass Koq name, baseClass Koq persistence unit name, child class Koq persistence unit name, child class Koq name */
+    IncompatibleUnitPropertyOverride: createPropertyDiagnosticClass(DiagnosticCodes.IncompatibleUnitPropertyOverride, "The ECProperty '{0}.{1}' has a base property '{2}.{1}' with KindOfQuantity '{3}' with persistence unit '{4}' which is not the same as the persistence unit '{5}' of the provided KindOfQuantity '{6}'."),
+    /** EC-1303: Required message parameters: property.fullName, navigation relationship.fullName */
+    NavigationRelationshipMustBeRoot: createPropertyDiagnosticClass(getCode(1303), "The referenced relationship '{1}', used in NavigationProperty '{0}' is not the root relationship."),
+    /** EC-1304: Required message parameters: property.fullName, navigation relationship.fullName */
+    NavigationTargetMustHaveSingularMultiplicity: createPropertyDiagnosticClass(getCode(1304), "NavigationProperty '{0}' uses the relationship '{1}' that cannot be traversed in the '{2}' direction due to a max multiplicity greater than 1."),
+    /** EC-1305: Required message parameters: property.fullName, navigation relationship.fullName */
+    NavigationRelationshipAbstractConstraintEntityOrMixin: createPropertyDiagnosticClass(getCode(1305), "The NavigationProperty '{0}', using the relationship '{1}', points to a RelationshipClass, which is not allowed.  NavigationProperties must point to an EntityClass or Mixin."),
+    /** EC-1306: Required message parameters: class name, property name, navigation relationship.fullName */
+    NavigationClassMustBeAConstraintClassOfRelationship: createPropertyDiagnosticClass(getCode(1306), "The class '{0}' of NavigationProperty '{1}' is not supported by the {3} constraint of the referenced relationship '{2}'."),
+    /** EC-1500: Required message parameters: abstract constraint class name, relationship end (source/target), relationship name, base relationship name */
+    AbstractConstraintMustNarrowBaseConstraints: createSchemaItemDiagnosticClass(DiagnosticCodes.AbstractConstraintMustNarrowBaseConstraints, "The abstract constraint class '{0}' on the {1}-Constraint of '{2}' is not supported by the base class constraint in '{3}'."),
+    /** EC-1501: Required message parameters: constraint class name, relationship end (source/target), relationship name, base relationship name */
+    DerivedConstraintsMustNarrowBaseConstraints: createSchemaItemDiagnosticClass(DiagnosticCodes.DerivedConstraintsMustNarrowBaseConstraints, "The constraint class '{0}' on the {1}-Constraint of '{2}' is not supported by the base class constraint in '{3}'."),
+    /** EC-1502: Required message parameters: constraint class name, relationship end (source/target), relationship name, abstract constraint class name */
+    ConstraintClassesDeriveFromAbstractConstraint: createSchemaItemDiagnosticClass(DiagnosticCodes.ConstraintClassesDeriveFromAbstractConstraint, "The constraint class '{0}' on the {1}-Constraint of '{2}' is not derived from the abstract constraint class '{3}'."),
+    /** EC-1600: Required message parameters: relationship end (source/target), relationship name */
+    AtLeastOneConstraintClassDefined: createRelationshipConstraintDiagnosticClass(DiagnosticCodes.AtLeastOneConstraintClassDefined, "The {0}-Constraint of '{1}' does not contain any constraint classes."),
+    /** EC-1601: Required message parameters: relationship end (source/target), relationship name */
+    AbstractConstraintMustExistWithMultipleConstraints: createRelationshipConstraintDiagnosticClass(DiagnosticCodes.AbstractConstraintMustExistWithMultipleConstraints, "The {0}-Constraint of '{1}' has multiple constraint classes which requires an abstract constraint to be defined."),
+};
+/**
+ * All schema validation rules that fall under the category of ECObjects.
+ * @beta
+ */
+export const ECRuleSet = {
+    name: ruleSetName,
+    schemaRules: [
+        validateSchemaReferences,
+    ],
+    classRules: [
+        baseClassIsSealed,
+        baseClassIsOfDifferentType,
+    ],
+    propertyRules: [
+        incompatibleValueTypePropertyOverride,
+        incompatibleTypePropertyOverride,
+        incompatibleUnitPropertyOverride,
+        validateNavigationProperty,
+    ],
+    relationshipRules: [
+        abstractConstraintMustNarrowBaseConstraints,
+        constraintClassesDeriveFromAbstractConstraint,
+        derivedConstraintsMustNarrowBaseConstraints,
+    ],
+    relationshipConstraintRules: [
+        atLeastOneConstraintClassDefined,
+        abstractConstraintMustExistWithMultipleConstraints,
+    ],
+    enumerationRules: [
+        enumerationTypeUnsupported,
+    ],
+    entityClassRules: [
+        mixinAppliedToClassMustDeriveFromConstraint,
+    ],
+    customAttributeInstanceRules: [
+        validateCustomAttributeInstance,
+    ],
+};
+/* eslint-enable @typescript-eslint/naming-convention */
+/**
+ * Validates schema references against multiple EC rules.
+ * @param schema The schema to validate.
+ * @internal
+ */
+export async function* validateSchemaReferences(schema) {
+    yield* validateSchemaReferencesSync(schema);
+}
+/**
+ * Validates schema references against multiple EC rules.
+ * @param schema The schema to validate.
+ * @internal
+ */
+export function* validateSchemaReferencesSync(schema) {
+    const aliases = new Map();
+    for (const schemaRef of schema.references) {
+        if (schemaRef.customAttributes && schemaRef.customAttributes.has("CoreCustomAttributes.SupplementalSchema"))
+            yield new Diagnostics.SupplementalSchemasCannotBeReferenced(schema, [schema.name, schemaRef.name]);
+        if (schema.schemaKey.matches(schemaRef.schemaKey))
+            yield new Diagnostics.ReferenceCyclesNotAllowed(schema, [schema.name, `${schema.name} --> ${schemaRef.name}`]);
+        if (aliases.has(schemaRef.alias)) {
+            const currentRef = aliases.get(schemaRef.alias);
+            yield new Diagnostics.SchemaRefAliasMustBeUnique(schema, [schema.name, schemaRef.alias, currentRef.name, schemaRef.name]);
+        }
+        else {
+            aliases.set(schemaRef.alias, schemaRef);
+        }
+    }
+    const graph = SchemaGraph.generateGraphSync(schema);
+    const cycles = graph.detectCycles();
+    if (cycles) {
+        const result = cycles.map((cycle) => `${cycle.schema.schemaKey.name} --> ${cycle.refSchema.schemaKey.name}`).join(", ");
+        yield new Diagnostics.ReferenceCyclesNotAllowed(schema, [schema.name, result]);
+    }
+}
+/**
+ * EC Rule: Sealed classes cannot be a base class.
+ * @internal
+ */
+export async function* baseClassIsSealed(ecClass) {
+    if (!ecClass.baseClass)
+        return;
+    const baseClass = await ecClass.baseClass;
+    // return if rule passed
+    if (baseClass.modifier !== ECClassModifier.Sealed)
+        return;
+    yield new Diagnostics.BaseClassIsSealed(ecClass, [ecClass.fullName, baseClass.fullName]);
+}
+/**
+ * EC Rule: Base and child class must be of the same type (i.e. Entity, Mixin, Relationship, etc.)
+ * @internal
+ */
+export async function* baseClassIsOfDifferentType(ecClass) {
+    if (!ecClass.baseClass)
+        return;
+    const baseClass = await ecClass.baseClass;
+    // return if rule passed
+    if (baseClass.schemaItemType === ecClass.schemaItemType)
+        return;
+    const itemType = baseClass.schemaItemType;
+    yield new Diagnostics.BaseClassIsOfDifferentType(ecClass, [ecClass.fullName, baseClass.fullName, itemType]);
+}
+/**
+ * EC Rule: When overriding a class primitive property, the child and base property must be of the same type (string, number, etc...).
+ * @internal
+*/
+export async function* incompatibleValueTypePropertyOverride(property) {
+    if (!property.class.baseClass)
+        return;
+    const primitiveType = getPrimitiveType(property);
+    if (!primitiveType)
+        return;
+    async function callback(baseClass) {
+        const baseProperty = await baseClass.getProperty(property.name);
+        if (!baseProperty)
+            return;
+        // Other rules will catch this if false, but we need to make sure
+        // types match for this rule to be valid.
+        if (!propertyTypesMatch(property, baseProperty))
+            return;
+        const baseType = getPrimitiveType(baseProperty);
+        // Return if rule passed
+        if (!baseType || primitiveType === baseType)
+            return;
+        return new Diagnostics.IncompatibleValueTypePropertyOverride(property, [property.class.fullName, property.name, baseClass.fullName, primitiveTypeToString(baseType), primitiveTypeToString(primitiveType)]);
+    }
+    for await (const baseClass of property.class.getAllBaseClasses()) {
+        const result = await callback(baseClass);
+        if (result)
+            yield result;
+    }
+}
+/**
+ * EC Rule: When overriding a class property, the child and base property must be of the same property type (primitive, struct, enumeration, etc...).
+ * @internal
+ */
+export async function* incompatibleTypePropertyOverride(property) {
+    if (!property.class.baseClass)
+        return;
+    async function callback(baseClass) {
+        const baseProperty = await baseClass.getProperty(property.name);
+        if (!baseProperty)
+            return;
+        // Return if rule passed
+        if (propertyTypesMatch(property, baseProperty))
+            return;
+        return new Diagnostics.IncompatibleTypePropertyOverride(property, [property.class.fullName, property.name, baseClass.fullName, baseProperty.constructor.name, property.constructor.name]);
+    }
+    for await (const baseClass of property.class.getAllBaseClasses()) {
+        const result = await callback(baseClass);
+        if (result)
+            yield result;
+    }
+}
+/**
+ * EC Rule: When overriding a kindOfQuantity property, the child and base property units must be the same.
+ * @internal
+ */
+export async function* incompatibleUnitPropertyOverride(property) {
+    if (!property.kindOfQuantity || !property.class.baseClass)
+        return;
+    async function callback(baseClass) {
+        const baseProperty = await baseClass.getProperty(property.name);
+        if (!baseProperty || !baseProperty.kindOfQuantity)
+            return;
+        // Other rules will catch this if false, but we need to make sure
+        // types match for this rule to be valid.
+        if (!propertyTypesMatch(property, baseProperty))
+            return;
+        const koq = await property.kindOfQuantity;
+        const baseKoq = await baseProperty.kindOfQuantity;
+        if (!koq || !baseKoq)
+            return;
+        const unit = await koq.persistenceUnit;
+        const baseUnit = await baseKoq.persistenceUnit;
+        if (!unit || !baseUnit)
+            return;
+        // return if rule passed
+        if (unit.key.matches(baseUnit.key))
+            return;
+        return new Diagnostics.IncompatibleUnitPropertyOverride(property, [
+            property.class.fullName,
+            property.name,
+            baseClass.fullName,
+            baseKoq.fullName,
+            baseUnit.fullName,
+            unit.fullName,
+            koq.fullName,
+        ]);
+    }
+    for await (const baseClass of property.class.getAllBaseClasses()) {
+        const result = await callback(baseClass);
+        if (result)
+            yield result;
+    }
+}
+/**
+ * Validates Navigation Properties. EC Rules: 1303, 1304
+ * @internal
+ */
+export async function* validateNavigationProperty(property) {
+    if (!property.isNavigation())
+        return;
+    const navProp = property;
+    const relationship = await navProp.relationshipClass;
+    if (relationship.baseClass)
+        yield new Diagnostics.NavigationRelationshipMustBeRoot(property, [property.fullName, relationship.fullName]);
+    let thisConstraint;
+    let thatConstraint;
+    let navigationClassSide;
+    if (navProp.direction === StrengthDirection.Forward) {
+        thisConstraint = relationship.source;
+        thatConstraint = relationship.target;
+        navigationClassSide = "source";
+    }
+    else {
+        thisConstraint = relationship.target;
+        thatConstraint = relationship.source;
+        navigationClassSide = "target";
+    }
+    const thatAbstractConstraint = await thatConstraint.abstractConstraint;
+    if (thatAbstractConstraint && thatAbstractConstraint.schemaItemType === SchemaItemType.RelationshipClass) {
+        yield new Diagnostics.NavigationRelationshipAbstractConstraintEntityOrMixin(property, [property.fullName, relationship.fullName]);
+    }
+    const isClassSupported = async (ecClass, propertyName, constraintName) => {
+        if (constraintName === ecClass.fullName && undefined !== await ecClass.getProperty(propertyName))
+            return true;
+        const inheritedProp = await ecClass.getInheritedProperty(propertyName);
+        if (inheritedProp && constraintName === inheritedProp.class.fullName)
+            return true;
+        const baseClass = await ecClass.baseClass;
+        if (!baseClass)
+            return false;
+        return isClassSupported(baseClass, propertyName, constraintName);
+    };
+    let classSupported = false;
+    if (thisConstraint.constraintClasses) {
+        for (const constraintClass of thisConstraint.constraintClasses) {
+            classSupported = await isClassSupported(property.class, property.name, constraintClass.fullName);
+            if (classSupported)
+                break;
+        }
+    }
+    if (!classSupported)
+        yield new Diagnostics.NavigationClassMustBeAConstraintClassOfRelationship(property, [property.class.name, property.name, relationship.fullName, navigationClassSide]);
+    if (thatConstraint.multiplicity === RelationshipMultiplicity.oneMany || thatConstraint.multiplicity === RelationshipMultiplicity.zeroMany) {
+        const direction = strengthDirectionToString(navProp.direction);
+        yield new Diagnostics.NavigationTargetMustHaveSingularMultiplicity(property, [property.fullName, relationship.fullName, direction]);
+    }
+    return;
+}
+/**
+ * Validates a Relationship class and yields EC-1500, EC-1501, and EC-1502 rule violations.
+ * @internal
+ */
+export async function* validateRelationship(ecClass) {
+    yield* abstractConstraintMustNarrowBaseConstraints(ecClass);
+    yield* derivedConstraintsMustNarrowBaseConstraints(ecClass);
+    yield* constraintClassesDeriveFromAbstractConstraint(ecClass);
+}
+/**
+ * EC Rule: When overriding a RelationshipClass, the derived abstract constraint must narrow the base constraint classes.
+ * @internal
+ */
+export async function* abstractConstraintMustNarrowBaseConstraints(ecClass) {
+    if (!ecClass.baseClass)
+        return;
+    const baseRelationship = await ecClass.baseClass;
+    const sourceResult = await applyAbstractConstraintMustNarrowBaseConstraints(ecClass, ecClass.source, baseRelationship);
+    if (sourceResult)
+        yield sourceResult;
+    const targetResult = await applyAbstractConstraintMustNarrowBaseConstraints(ecClass, ecClass.target, baseRelationship);
+    if (targetResult)
+        yield targetResult;
+}
+/**
+ * EC Rule: When overriding a RelationshipClass, derived constraint classes must narrow base constraint classes.
+ * @internal
+ */
+export async function* derivedConstraintsMustNarrowBaseConstraints(ecClass) {
+    if (!ecClass.baseClass)
+        return;
+    const baseRelationship = await ecClass.baseClass;
+    const sourceResult = await applyDerivedConstraintsMustNarrowBaseConstraints(ecClass, ecClass.source, baseRelationship);
+    if (sourceResult)
+        yield sourceResult;
+    const targetResult = await applyDerivedConstraintsMustNarrowBaseConstraints(ecClass, ecClass.target, baseRelationship);
+    if (targetResult)
+        yield targetResult;
+}
+/**
+ * EC Rule: All constraint classes must have a common base class specified in the abstract constraint.
+ * @internal
+ */
+export async function* constraintClassesDeriveFromAbstractConstraint(ecClass) {
+    const sourceResult = await applyConstraintClassesDeriveFromAbstractConstraint(ecClass, ecClass.source);
+    if (sourceResult)
+        yield sourceResult;
+    const targetResult = await applyConstraintClassesDeriveFromAbstractConstraint(ecClass, ecClass.target);
+    if (targetResult)
+        yield targetResult;
+}
+/**
+ * Validates a RelationshipConstraint and yields EC-1600 and EC-1601 rule violations.
+ * @internal
+ */
+export async function* validateRelationshipConstraint(constraint) {
+    yield* atLeastOneConstraintClassDefined(constraint);
+    yield* abstractConstraintMustExistWithMultipleConstraints(constraint);
+}
+/**
+ * EC Rule: At least on concrete constraint class must be defined in the list of constraint classes.
+ * @internal
+ */
+export async function* atLeastOneConstraintClassDefined(constraint) {
+    if (!constraint.constraintClasses || constraint.constraintClasses.length === 0) {
+        const constraintType = constraint.isSource ? ECStringConstants.RELATIONSHIP_END_SOURCE : ECStringConstants.RELATIONSHIP_END_TARGET;
+        yield new Diagnostics.AtLeastOneConstraintClassDefined(constraint, [constraintType, constraint.relationshipClass.fullName]);
+    }
+}
+/**
+ * EC Rule: If multiple constraints exist, an abstract constraint must be defined.
+ * @internal
+ */
+export async function* abstractConstraintMustExistWithMultipleConstraints(constraint) {
+    if (!constraint.constraintClasses || constraint.constraintClasses.length <= 1) {
+        return;
+    }
+    const abstractConstraint = await getAbstractConstraint(constraint);
+    if (abstractConstraint)
+        return;
+    const constraintType = constraint.isSource ? ECStringConstants.RELATIONSHIP_END_SOURCE : ECStringConstants.RELATIONSHIP_END_TARGET;
+    yield new Diagnostics.AbstractConstraintMustExistWithMultipleConstraints(constraint, [constraintType, constraint.relationshipClass.fullName]);
+}
+function propertyTypesMatch(propertyA, propertyB) {
+    return propertyA.constructor.name === propertyB.constructor.name;
+}
+function getPrimitiveType(property) {
+    if (property.isPrimitive())
+        return property.primitiveType;
+    return undefined;
+}
+/**
+ * EC Rule: Enumeration type must be a string or integer
+ * @internal
+ */
+export async function* enumerationTypeUnsupported(enumeration) {
+    const type = enumeration.type;
+    if (type === PrimitiveType.Integer || type === PrimitiveType.String)
+        return;
+    yield new Diagnostics.EnumerationTypeUnsupported(enumeration, [enumeration.fullName]);
+}
+/**
+ * EC Rule: Mixin applied to class must derived from the Mixin appliesTo constraint.
+ * @internal
+ */
+export async function* mixinAppliedToClassMustDeriveFromConstraint(entityClass) {
+    for (const lazyMixin of entityClass.mixins) {
+        const mixin = await lazyMixin;
+        if (!mixin.appliesTo)
+            continue;
+        if (!await entityClass.is(await mixin.appliesTo))
+            yield new Diagnostics.MixinAppliedToClassMustDeriveFromConstraint(entityClass, [mixin.fullName, entityClass.fullName, mixin.appliesTo.fullName]);
+    }
+    return;
+}
+/**
+ * Validates a custom attribute instance and yields EC-500, EC-501, and EC-502 rule violations.
+ * @internal
+ */
+export async function* validateCustomAttributeInstance(container, customAttribute) {
+    yield* customAttributeNotOfConcreteClass(container, customAttribute);
+    yield* customAttributeSchemaMustBeReferenced(container, customAttribute);
+    yield* customAttributeClassMustExist(container, customAttribute);
+}
+/** EC Rule: CustomAttribute instance must be of a concrete CustomAttributeClass. */
+async function* customAttributeNotOfConcreteClass(container, customAttribute) {
+    const schema = container.schema;
+    const caClass = await schema.lookupItem(customAttribute.className);
+    if (!caClass)
+        return;
+    if (caClass.modifier !== ECClassModifier.Abstract)
+        return;
+    yield new Diagnostics.CustomAttributeNotOfConcreteClass(container, [container.fullName, caClass.fullName]);
+}
+/** EC Rule: CustomAttribute Schema must be referenced by the container's Schema. */
+async function* customAttributeSchemaMustBeReferenced(container, customAttribute) {
+    const schema = container.schema;
+    const nameParts = customAttribute.className.split(".");
+    if (nameParts.length === 1 || nameParts[0] === schema.name)
+        return;
+    if (schema.references.some((s) => s.name === nameParts[0]))
+        return;
+    yield new Diagnostics.CustomAttributeSchemaMustBeReferenced(container, [container.fullName, customAttribute.className]);
+}
+/** EC Rule: CustomAttribute instance class must exist. */
+async function* customAttributeClassMustExist(container, customAttribute) {
+    const schema = container.schema;
+    const caClass = await schema.lookupItem(customAttribute.className);
+    if (!caClass)
+        yield new Diagnostics.CustomAttributeClassNotFound(container, [container.fullName, customAttribute.className]);
+}
+async function applyAbstractConstraintMustNarrowBaseConstraints(ecClass, constraint, baseRelationship) {
+    const baseConstraint = constraint.isSource ? baseRelationship.source : baseRelationship.target;
+    const abstractConstraint = await constraint.abstractConstraint;
+    if (!abstractConstraint)
+        return;
+    if (await baseConstraint.supportsClass(abstractConstraint))
+        return;
+    const constraintType = constraint.isSource ? ECStringConstants.RELATIONSHIP_END_SOURCE : ECStringConstants.RELATIONSHIP_END_TARGET;
+    return new Diagnostics.AbstractConstraintMustNarrowBaseConstraints(ecClass, [abstractConstraint.fullName, constraintType, constraint.relationshipClass.fullName, baseRelationship.fullName]);
+}
+async function applyDerivedConstraintsMustNarrowBaseConstraints(ecClass, constraint, baseRelationship) {
+    const baseConstraint = constraint.isSource ? baseRelationship.source : baseRelationship.target;
+    if (!constraint.constraintClasses)
+        return;
+    for (const classPromise of constraint.constraintClasses) {
+        const constraintClass = await classPromise;
+        if (await baseConstraint.supportsClass(constraintClass))
+            continue;
+        const constraintType = constraint.isSource ? ECStringConstants.RELATIONSHIP_END_SOURCE : ECStringConstants.RELATIONSHIP_END_TARGET;
+        return new Diagnostics.DerivedConstraintsMustNarrowBaseConstraints(ecClass, [constraintClass.fullName, constraintType, constraint.relationshipClass.fullName, baseRelationship.fullName]);
+    }
+    return;
+}
+async function applyConstraintClassesDeriveFromAbstractConstraint(ecClass, constraint) {
+    const abstractConstraint = await getAbstractConstraint(constraint);
+    if (!abstractConstraint)
+        return;
+    if (!constraint.constraintClasses)
+        return;
+    for (const classPromise of constraint.constraintClasses) {
+        const constraintClass = await classPromise;
+        if (Mixin.isMixin(constraintClass) && EntityClass.isEntityClass(abstractConstraint)) {
+            if (!await (constraintClass).applicableTo(abstractConstraint)) {
+                const constraintType = constraint.isSource ? ECStringConstants.RELATIONSHIP_END_SOURCE : ECStringConstants.RELATIONSHIP_END_TARGET;
+                return new Diagnostics.ConstraintClassesDeriveFromAbstractConstraint(ecClass, [constraintClass.fullName, constraintType, constraint.relationshipClass.fullName, abstractConstraint.fullName]);
+            }
+            continue;
+        }
+        if (!await constraintClass.is(abstractConstraint)) {
+            const constraintType = constraint.isSource ? ECStringConstants.RELATIONSHIP_END_SOURCE : ECStringConstants.RELATIONSHIP_END_TARGET;
+            return new Diagnostics.ConstraintClassesDeriveFromAbstractConstraint(ecClass, [constraintClass.fullName, constraintType, constraint.relationshipClass.fullName, abstractConstraint.fullName]);
+        }
+    }
+    return;
+}
+async function getAbstractConstraint(constraint) {
+    const abstractConstraint = await constraint.abstractConstraint;
+    if (abstractConstraint)
+        return abstractConstraint;
+    const baseRelationship = await constraint.relationshipClass.baseClass;
+    if (!baseRelationship)
+        return;
+    const baseConstraint = constraint.isSource ? baseRelationship.source : baseRelationship.target;
+    return getAbstractConstraint(baseConstraint);
+}
+//# sourceMappingURL=ECRules.js.map