@itwin/ecschema-editing 3.0.0-dev.72

package/lib/Validation/ECRules.js

@@ -0,0 +1,679 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* 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
+ */
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncDelegator = (this && this.__asyncDelegator) || function (o) {
+    var i, p;
+    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
+};
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateCustomAttributeInstance = exports.mixinAppliedToClassMustDeriveFromConstraint = exports.enumerationTypeUnsupported = exports.abstractConstraintMustExistWithMultipleConstraints = exports.atLeastOneConstraintClassDefined = exports.constraintClassesDeriveFromAbstractContraint = exports.derivedConstraintsMustNarrowBaseConstraints = exports.abstractConstraintMustNarrowBaseConstraints = exports.validateNavigationProperty = exports.incompatibleUnitPropertyOverride = exports.incompatibleTypePropertyOverride = exports.incompatibleValueTypePropertyOverride = exports.abstractClassWithNonAbstractBase = exports.baseClassIsOfDifferentType = exports.baseClassIsSealed = exports.validateSchemaReferencesSync = exports.validateSchemaReferences = exports.ECRuleSet = exports.Diagnostics = exports.DiagnosticCodes = void 0;
+const ecschema_metadata_1 = require("@itwin/ecschema-metadata");
+const Diagnostic_1 = require("./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 */
+exports.DiagnosticCodes = {
+    // Class Rule Codes (100-199)
+    BaseClassIsSealed: getCode(100),
+    BaseClassOfDifferentType: getCode(101),
+    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),
+    ConstraintClassesDeriveFromAbstractContraint: 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
+ */
+exports.Diagnostics = {
+    /** EC-001: Required message parameters: schema name, referenced schema name */
+    SupplementalSchemasCannotBeReferenced: (0, Diagnostic_1.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: (0, Diagnostic_1.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: (0, Diagnostic_1.createSchemaDiagnosticClass)(getCode(3), "Schema '{0}' has reference cycles: {1}"),
+    /** EC-100: Required message parameters: childClass.FullName, baseClass.FullName */
+    BaseClassIsSealed: (0, Diagnostic_1.createClassDiagnosticClass)(exports.DiagnosticCodes.BaseClassIsSealed, "Class '{0}' cannot derive from sealed base class '{1}'."),
+    /** EC-101: Required message parameters: childClass.FullName, baseClass.FullName, baseClass.schemaItemType */
+    BaseClassIsOfDifferentType: (0, Diagnostic_1.createClassDiagnosticClass)(exports.DiagnosticCodes.BaseClassOfDifferentType, "Class '{0}' cannot derive from base class '{1}' of type '{2}'."),
+    /** EC-102: Required message parameters: childClass.FullName, baseClass.FullName */
+    AbstractClassWithNonAbstractBase: (0, Diagnostic_1.createClassDiagnosticClass)(exports.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: (0, Diagnostic_1.createCustomAttributeContainerDiagnosticClass)(exports.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: (0, Diagnostic_1.createCustomAttributeContainerDiagnosticClass)(exports.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: (0, Diagnostic_1.createCustomAttributeContainerDiagnosticClass)(exports.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: (0, Diagnostic_1.createSchemaItemDiagnosticClass)(exports.DiagnosticCodes.EnumerationTypeUnsupported, "Enumeration '{0}' has invalid primitive type."),
+    /** EC-1100: Required message parameters: mixin class fullName, class fullName, applies to constraint class fullName */
+    MixinAppliedToClassMustDeriveFromConstraint: (0, Diagnostic_1.createSchemaItemDiagnosticClass)(exports.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: (0, Diagnostic_1.createPropertyDiagnosticClass)(exports.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: (0, Diagnostic_1.createPropertyDiagnosticClass)(exports.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: (0, Diagnostic_1.createPropertyDiagnosticClass)(exports.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: (0, Diagnostic_1.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: (0, Diagnostic_1.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: (0, Diagnostic_1.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: (0, Diagnostic_1.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: (0, Diagnostic_1.createSchemaItemDiagnosticClass)(exports.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: (0, Diagnostic_1.createSchemaItemDiagnosticClass)(exports.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 */
+    ConstraintClassesDeriveFromAbstractContraint: (0, Diagnostic_1.createSchemaItemDiagnosticClass)(exports.DiagnosticCodes.ConstraintClassesDeriveFromAbstractContraint, "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: (0, Diagnostic_1.createRelationshipConstraintDiagnosticClass)(exports.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: (0, Diagnostic_1.createRelationshipConstraintDiagnosticClass)(exports.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
+ */
+exports.ECRuleSet = {
+    name: ruleSetName,
+    schemaRules: [
+        validateSchemaReferences,
+    ],
+    classRules: [
+        baseClassIsSealed,
+        baseClassIsOfDifferentType,
+        abstractClassWithNonAbstractBase,
+    ],
+    propertyRules: [
+        incompatibleValueTypePropertyOverride,
+        incompatibleTypePropertyOverride,
+        incompatibleUnitPropertyOverride,
+        validateNavigationProperty,
+    ],
+    relationshipRules: [
+        abstractConstraintMustNarrowBaseConstraints,
+        constraintClassesDeriveFromAbstractContraint,
+        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.
+ */
+function validateSchemaReferences(schema) {
+    return __asyncGenerator(this, arguments, function* validateSchemaReferences_1() {
+        yield __await(yield* __asyncDelegator(__asyncValues(validateSchemaReferencesSync(schema))));
+    });
+}
+exports.validateSchemaReferences = validateSchemaReferences;
+function* validateSchemaReferencesSync(schema) {
+    const aliases = new Map();
+    for (const schemaRef of schema.references) {
+        if (schemaRef.customAttributes && schemaRef.customAttributes.has("CoreCustomAttributes.SupplementalSchema"))
+            yield new exports.Diagnostics.SupplementalSchemasCannotBeReferenced(schema, [schema.name, schemaRef.name]);
+        if (schema.schemaKey.matches(schemaRef.schemaKey))
+            yield new exports.Diagnostics.ReferenceCyclesNotAllowed(schema, [schema.name, `${schema.name} --> ${schemaRef.name}`]);
+        if (aliases.has(schemaRef.alias)) {
+            const currentRef = aliases.get(schemaRef.alias);
+            yield new exports.Diagnostics.SchemaRefAliasMustBeUnique(schema, [schema.name, schemaRef.alias, currentRef.name, schemaRef.name]);
+        }
+        else {
+            aliases.set(schemaRef.alias, schemaRef);
+        }
+    }
+    const graph = new ecschema_metadata_1.SchemaGraph(schema);
+    const cycles = graph.detectCycles();
+    if (cycles) {
+        const result = cycles.map((cycle) => `${cycle.schema.name} --> ${cycle.refSchema.name}`).join(", ");
+        yield new exports.Diagnostics.ReferenceCyclesNotAllowed(schema, [schema.name, result]);
+    }
+}
+exports.validateSchemaReferencesSync = validateSchemaReferencesSync;
+/**
+ * EC Rule: Sealed classes cannot be a base class.
+ * @internal
+ */
+function baseClassIsSealed(ecClass) {
+    return __asyncGenerator(this, arguments, function* baseClassIsSealed_1() {
+        if (!ecClass.baseClass)
+            return yield __await(void 0);
+        const baseClass = yield __await(ecClass.baseClass);
+        // return if rule passed
+        if (baseClass.modifier !== ecschema_metadata_1.ECClassModifier.Sealed)
+            return yield __await(void 0);
+        yield yield __await(new exports.Diagnostics.BaseClassIsSealed(ecClass, [ecClass.fullName, baseClass.fullName]));
+    });
+}
+exports.baseClassIsSealed = baseClassIsSealed;
+/**
+ * EC Rule: Base and child class must be of the same type (i.e. Entity, Mixin, Relationship, etc.)
+ * @internal
+ */
+function baseClassIsOfDifferentType(ecClass) {
+    return __asyncGenerator(this, arguments, function* baseClassIsOfDifferentType_1() {
+        if (!ecClass.baseClass)
+            return yield __await(void 0);
+        const baseClass = yield __await(ecClass.baseClass);
+        // return if rule passed
+        if (baseClass.schemaItemType === ecClass.schemaItemType)
+            return yield __await(void 0);
+        const itemType = (0, ecschema_metadata_1.schemaItemTypeToString)(baseClass.schemaItemType);
+        yield yield __await(new exports.Diagnostics.BaseClassIsOfDifferentType(ecClass, [ecClass.fullName, baseClass.fullName, itemType]));
+    });
+}
+exports.baseClassIsOfDifferentType = baseClassIsOfDifferentType;
+/**
+ * EC Rule: Abstract class cannot derive from a non-abstract base class.
+ * @internal
+ */
+function abstractClassWithNonAbstractBase(ecClass) {
+    return __asyncGenerator(this, arguments, function* abstractClassWithNonAbstractBase_1() {
+        if (ecClass.modifier !== ecschema_metadata_1.ECClassModifier.Abstract || !ecClass.baseClass)
+            return yield __await(void 0);
+        const baseClass = yield __await(ecClass.baseClass);
+        // return if rule passed
+        if (baseClass.modifier === ecschema_metadata_1.ECClassModifier.Abstract)
+            return yield __await(void 0);
+        yield yield __await(new exports.Diagnostics.AbstractClassWithNonAbstractBase(ecClass, [ecClass.fullName, baseClass.fullName]));
+    });
+}
+exports.abstractClassWithNonAbstractBase = abstractClassWithNonAbstractBase;
+/**
+ * EC Rule: When overriding a class primitive property, the child and base property must be of the same type (string, number, etc...).
+ * @internal
+*/
+function incompatibleValueTypePropertyOverride(property) {
+    return __asyncGenerator(this, arguments, function* incompatibleValueTypePropertyOverride_1() {
+        var e_1, _a;
+        if (!property.class.baseClass)
+            return yield __await(void 0);
+        const primitiveType = getPrimitiveType(property);
+        if (!primitiveType)
+            return yield __await(void 0);
+        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 exports.Diagnostics.IncompatibleValueTypePropertyOverride(property, [property.class.fullName, property.name, baseClass.fullName, (0, ecschema_metadata_1.primitiveTypeToString)(baseType), (0, ecschema_metadata_1.primitiveTypeToString)(primitiveType)]);
+        }
+        try {
+            for (var _b = __asyncValues(property.class.getAllBaseClasses()), _c; _c = yield __await(_b.next()), !_c.done;) {
+                const baseClass = _c.value;
+                const result = yield __await(callback(baseClass));
+                if (result)
+                    yield yield __await(result);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) yield __await(_a.call(_b));
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    });
+}
+exports.incompatibleValueTypePropertyOverride = incompatibleValueTypePropertyOverride;
+/**
+ * EC Rule: When overriding a class property, the child and base property must be of the same property type (primitive, struct, enumeration, etc...).
+ * @internal
+ */
+function incompatibleTypePropertyOverride(property) {
+    return __asyncGenerator(this, arguments, function* incompatibleTypePropertyOverride_1() {
+        var e_2, _a;
+        if (!property.class.baseClass)
+            return yield __await(void 0);
+        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 exports.Diagnostics.IncompatibleTypePropertyOverride(property, [property.class.fullName, property.name, baseClass.fullName, baseProperty.constructor.name, property.constructor.name]);
+        }
+        try {
+            for (var _b = __asyncValues(property.class.getAllBaseClasses()), _c; _c = yield __await(_b.next()), !_c.done;) {
+                const baseClass = _c.value;
+                const result = yield __await(callback(baseClass));
+                if (result)
+                    yield yield __await(result);
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) yield __await(_a.call(_b));
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+    });
+}
+exports.incompatibleTypePropertyOverride = incompatibleTypePropertyOverride;
+/**
+ * EC Rule: When overriding a kindOfQuantity property, the child and base property units must be the same.
+ * @internal
+ */
+function incompatibleUnitPropertyOverride(property) {
+    return __asyncGenerator(this, arguments, function* incompatibleUnitPropertyOverride_1() {
+        var e_3, _a;
+        if (!property.kindOfQuantity || !property.class.baseClass)
+            return yield __await(void 0);
+        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 exports.Diagnostics.IncompatibleUnitPropertyOverride(property, [
+                property.class.fullName,
+                property.name,
+                baseClass.fullName,
+                baseKoq.fullName,
+                baseUnit.fullName,
+                unit.fullName,
+                koq.fullName,
+            ]);
+        }
+        try {
+            for (var _b = __asyncValues(property.class.getAllBaseClasses()), _c; _c = yield __await(_b.next()), !_c.done;) {
+                const baseClass = _c.value;
+                const result = yield __await(callback(baseClass));
+                if (result)
+                    yield yield __await(result);
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) yield __await(_a.call(_b));
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+    });
+}
+exports.incompatibleUnitPropertyOverride = incompatibleUnitPropertyOverride;
+/** Validates Navigation Properties. EC Rules: 1303, 1304 */
+function validateNavigationProperty(property) {
+    return __asyncGenerator(this, arguments, function* validateNavigationProperty_1() {
+        if (!property.isNavigation())
+            return yield __await(void 0);
+        const navProp = property;
+        const relationship = yield __await(navProp.relationshipClass);
+        if (relationship.baseClass)
+            yield yield __await(new exports.Diagnostics.NavigationRelationshipMustBeRoot(property, [property.fullName, relationship.fullName]));
+        let thisConstraint;
+        let thatConstraint;
+        let navigationClassSide;
+        if (navProp.direction === ecschema_metadata_1.StrengthDirection.Forward) {
+            thisConstraint = relationship.source;
+            thatConstraint = relationship.target;
+            navigationClassSide = "source";
+        }
+        else {
+            thisConstraint = relationship.target;
+            thatConstraint = relationship.source;
+            navigationClassSide = "target";
+        }
+        const thatAbstractConstraint = yield __await(thatConstraint.abstractConstraint);
+        if (thatAbstractConstraint && thatAbstractConstraint.schemaItemType === ecschema_metadata_1.SchemaItemType.RelationshipClass) {
+            yield yield __await(new exports.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 = yield __await(isClassSupported(property.class, property.name, constraintClass.fullName));
+                if (classSupported)
+                    break;
+            }
+        }
+        if (!classSupported)
+            yield yield __await(new exports.Diagnostics.NavigationClassMustBeAConstraintClassOfRelationship(property, [property.class.name, property.name, relationship.fullName, navigationClassSide]));
+        if (thatConstraint.multiplicity === ecschema_metadata_1.RelationshipMultiplicity.oneMany || thatConstraint.multiplicity === ecschema_metadata_1.RelationshipMultiplicity.zeroMany) {
+            const direction = (0, ecschema_metadata_1.strengthDirectionToString)(navProp.direction);
+            yield yield __await(new exports.Diagnostics.NavigationTargetMustHaveSingularMultiplicity(property, [property.fullName, relationship.fullName, direction]));
+        }
+        return yield __await(void 0);
+    });
+}
+exports.validateNavigationProperty = validateNavigationProperty;
+/**
+ * EC Rule: When overriding a RelationshipClass, the derived abstract constraint must narrow the base constraint classes.
+ * @internal
+ */
+function abstractConstraintMustNarrowBaseConstraints(ecClass) {
+    return __asyncGenerator(this, arguments, function* abstractConstraintMustNarrowBaseConstraints_1() {
+        if (!ecClass.baseClass)
+            return yield __await(void 0);
+        const baseRelationship = yield __await(ecClass.baseClass);
+        const sourceResult = yield __await(applyAbstractConstraintMustNarrowBaseConstraints(ecClass, ecClass.source, baseRelationship));
+        if (sourceResult)
+            yield yield __await(sourceResult);
+        const targetResult = yield __await(applyAbstractConstraintMustNarrowBaseConstraints(ecClass, ecClass.target, baseRelationship));
+        if (targetResult)
+            yield yield __await(targetResult);
+    });
+}
+exports.abstractConstraintMustNarrowBaseConstraints = abstractConstraintMustNarrowBaseConstraints;
+/**
+ * EC Rule: When overriding a RelationshipClass, derived constraint classes must narrow base constraint classes.
+ * @internal
+ */
+function derivedConstraintsMustNarrowBaseConstraints(ecClass) {
+    return __asyncGenerator(this, arguments, function* derivedConstraintsMustNarrowBaseConstraints_1() {
+        if (!ecClass.baseClass)
+            return yield __await(void 0);
+        const baseRelationship = yield __await(ecClass.baseClass);
+        const sourceResult = yield __await(applyDerivedConstraintsMustNarrowBaseConstraints(ecClass, ecClass.source, baseRelationship));
+        if (sourceResult)
+            yield yield __await(sourceResult);
+        const targetResult = yield __await(applyDerivedConstraintsMustNarrowBaseConstraints(ecClass, ecClass.target, baseRelationship));
+        if (targetResult)
+            yield yield __await(targetResult);
+    });
+}
+exports.derivedConstraintsMustNarrowBaseConstraints = derivedConstraintsMustNarrowBaseConstraints;
+/**
+ * EC Rule: All constraint classes must have a common base class specified in the abstract constraint.
+ * @internal
+ */
+function constraintClassesDeriveFromAbstractContraint(ecClass) {
+    return __asyncGenerator(this, arguments, function* constraintClassesDeriveFromAbstractContraint_1() {
+        const sourceResult = yield __await(applyConstraintClassesDeriveFromAbstractContraint(ecClass, ecClass.source));
+        if (sourceResult)
+            yield yield __await(sourceResult);
+        const targetResult = yield __await(applyConstraintClassesDeriveFromAbstractContraint(ecClass, ecClass.target));
+        if (targetResult)
+            yield yield __await(targetResult);
+    });
+}
+exports.constraintClassesDeriveFromAbstractContraint = constraintClassesDeriveFromAbstractContraint;
+/**
+ * EC Rule: At least on concrete constraint class must be defined in the list of constraint classes.
+ * @internal
+ */
+function atLeastOneConstraintClassDefined(constraint) {
+    return __asyncGenerator(this, arguments, function* atLeastOneConstraintClassDefined_1() {
+        if (!constraint.constraintClasses || constraint.constraintClasses.length === 0) {
+            const constraintType = constraint.isSource ? ecschema_metadata_1.ECStringConstants.RELATIONSHIP_END_SOURCE : ecschema_metadata_1.ECStringConstants.RELATIONSHIP_END_TARGET;
+            yield yield __await(new exports.Diagnostics.AtLeastOneConstraintClassDefined(constraint, [constraintType, constraint.relationshipClass.fullName]));
+        }
+    });
+}
+exports.atLeastOneConstraintClassDefined = atLeastOneConstraintClassDefined;
+/**
+ * EC Rule: If multiple constraints exist, an abstract constraint must be defined.
+ * @internal
+ */
+function abstractConstraintMustExistWithMultipleConstraints(constraint) {
+    return __asyncGenerator(this, arguments, function* abstractConstraintMustExistWithMultipleConstraints_1() {
+        if (!constraint.constraintClasses || constraint.constraintClasses.length <= 1) {
+            return yield __await(void 0);
+        }
+        const abstractConstraint = yield __await(getAbstractConstraint(constraint));
+        if (abstractConstraint)
+            return yield __await(void 0);
+        const constraintType = constraint.isSource ? ecschema_metadata_1.ECStringConstants.RELATIONSHIP_END_SOURCE : ecschema_metadata_1.ECStringConstants.RELATIONSHIP_END_TARGET;
+        yield yield __await(new exports.Diagnostics.AbstractConstraintMustExistWithMultipleConstraints(constraint, [constraintType, constraint.relationshipClass.fullName]));
+    });
+}
+exports.abstractConstraintMustExistWithMultipleConstraints = abstractConstraintMustExistWithMultipleConstraints;
+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
+ */
+function enumerationTypeUnsupported(enumeration) {
+    return __asyncGenerator(this, arguments, function* enumerationTypeUnsupported_1() {
+        const type = enumeration.type;
+        if (type === ecschema_metadata_1.PrimitiveType.Integer || type === ecschema_metadata_1.PrimitiveType.String)
+            return yield __await(void 0);
+        yield yield __await(new exports.Diagnostics.EnumerationTypeUnsupported(enumeration, [enumeration.fullName]));
+    });
+}
+exports.enumerationTypeUnsupported = enumerationTypeUnsupported;
+/**
+ * EC Rule: Mixin applied to class must derived from the Mixin appliesTo constraint.
+ * @internal
+ */
+function mixinAppliedToClassMustDeriveFromConstraint(entityClass) {
+    return __asyncGenerator(this, arguments, function* mixinAppliedToClassMustDeriveFromConstraint_1() {
+        for (const lazyMixin of entityClass.mixins) {
+            const mixin = yield __await(lazyMixin);
+            if (!mixin.appliesTo)
+                continue;
+            if (!(yield __await(entityClass.is(yield __await(mixin.appliesTo)))))
+                yield yield __await(new exports.Diagnostics.MixinAppliedToClassMustDeriveFromConstraint(entityClass, [mixin.fullName, entityClass.fullName, mixin.appliesTo.fullName]));
+        }
+        return yield __await(void 0);
+    });
+}
+exports.mixinAppliedToClassMustDeriveFromConstraint = mixinAppliedToClassMustDeriveFromConstraint;
+/**
+ * Validates a custom attribute instance and yields EC-500, EC-501, and EC-502 rule violations.
+ */
+function validateCustomAttributeInstance(container, customAttribute) {
+    return __asyncGenerator(this, arguments, function* validateCustomAttributeInstance_1() {
+        yield __await(yield* __asyncDelegator(__asyncValues(customAttributeNotOfConcreteClass(container, customAttribute))));
+        yield __await(yield* __asyncDelegator(__asyncValues(customAttributeSchemaMustBeReferenced(container, customAttribute))));
+        yield __await(yield* __asyncDelegator(__asyncValues(customAttributeClassMustExist(container, customAttribute))));
+    });
+}
+exports.validateCustomAttributeInstance = validateCustomAttributeInstance;
+/** EC Rule: CustomAttribute instance must be of a concrete CustomAttributeClass. */
+function customAttributeNotOfConcreteClass(container, customAttribute) {
+    return __asyncGenerator(this, arguments, function* customAttributeNotOfConcreteClass_1() {
+        const schema = container.schema;
+        const caClass = yield __await(schema.lookupItem(customAttribute.className));
+        if (!caClass)
+            return yield __await(void 0);
+        if (caClass.modifier !== ecschema_metadata_1.ECClassModifier.Abstract)
+            return yield __await(void 0);
+        yield yield __await(new exports.Diagnostics.CustomAttributeNotOfConcreteClass(container, [container.fullName, caClass.fullName]));
+    });
+}
+/** EC Rule: CustomAttribute Schema must be referenced by the container's Schema. */
+function customAttributeSchemaMustBeReferenced(container, customAttribute) {
+    return __asyncGenerator(this, arguments, function* customAttributeSchemaMustBeReferenced_1() {
+        const schema = container.schema;
+        const nameParts = customAttribute.className.split(".");
+        if (nameParts.length === 1 || nameParts[0] === schema.name)
+            return yield __await(void 0);
+        if (schema.references.some((s) => s.name === nameParts[0]))
+            return yield __await(void 0);
+        yield yield __await(new exports.Diagnostics.CustomAttributeSchemaMustBeReferenced(container, [container.fullName, customAttribute.className]));
+    });
+}
+/** EC Rule: CustomAttribute instance class must exist. */
+function customAttributeClassMustExist(container, customAttribute) {
+    return __asyncGenerator(this, arguments, function* customAttributeClassMustExist_1() {
+        const schema = container.schema;
+        const caClass = yield __await(schema.lookupItem(customAttribute.className));
+        if (!caClass)
+            yield yield __await(new exports.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 ? ecschema_metadata_1.ECStringConstants.RELATIONSHIP_END_SOURCE : ecschema_metadata_1.ECStringConstants.RELATIONSHIP_END_TARGET;
+    return new exports.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 ? ecschema_metadata_1.ECStringConstants.RELATIONSHIP_END_SOURCE : ecschema_metadata_1.ECStringConstants.RELATIONSHIP_END_TARGET;
+        return new exports.Diagnostics.DerivedConstraintsMustNarrowBaseConstraints(ecClass, [constraintClass.fullName, constraintType, constraint.relationshipClass.fullName, baseRelationship.fullName]);
+    }
+    return;
+}
+async function applyConstraintClassesDeriveFromAbstractContraint(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 (constraintClass.schemaItemType === ecschema_metadata_1.SchemaItemType.Mixin && abstractConstraint.schemaItemType === ecschema_metadata_1.SchemaItemType.EntityClass) {
+            if (!await (constraintClass).applicableTo(abstractConstraint)) {
+                const constraintType = constraint.isSource ? ecschema_metadata_1.ECStringConstants.RELATIONSHIP_END_SOURCE : ecschema_metadata_1.ECStringConstants.RELATIONSHIP_END_TARGET;
+                return new exports.Diagnostics.ConstraintClassesDeriveFromAbstractContraint(ecClass, [constraintClass.fullName, constraintType, constraint.relationshipClass.fullName, abstractConstraint.fullName]);
+            }
+            continue;
+        }
+        if (!await constraintClass.is(abstractConstraint)) {
+            const constraintType = constraint.isSource ? ecschema_metadata_1.ECStringConstants.RELATIONSHIP_END_SOURCE : ecschema_metadata_1.ECStringConstants.RELATIONSHIP_END_TARGET;
+            return new exports.Diagnostics.ConstraintClassesDeriveFromAbstractContraint(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