Derived class caching

common/api/ecschema-editing.api.md

@@ -1928,25 +1928,25 @@ export const SchemaCompareDiagnostics: {
         diagnosticType: DiagnosticType;
     };
     FormatUnitMissing: {
-        new (ecDefinition: SchemaItem, messageArgs: [Unit | InvertedUnit], category?: DiagnosticCategory): {
+        new (ecDefinition: SchemaItem, messageArgs: [InvertedUnit | Unit], category?: DiagnosticCategory): {
             readonly code: string;
             readonly messageText: string;
             readonly schema: Schema;
             readonly diagnosticType: DiagnosticType;
             ecDefinition: Format;
-            messageArgs?: [Unit | InvertedUnit] | undefined;
+            messageArgs?: [InvertedUnit | Unit] | undefined;
             category: DiagnosticCategory;
         };
         diagnosticType: DiagnosticType;
     };
     UnitLabelOverrideDelta: {
-        new (ecDefinition: SchemaItem, messageArgs: [Unit | InvertedUnit, string | undefined, string | undefined], category?: DiagnosticCategory): {
+        new (ecDefinition: SchemaItem, messageArgs: [InvertedUnit | Unit, string | undefined, string | undefined], category?: DiagnosticCategory): {
             readonly code: string;
             readonly messageText: string;
             readonly schema: Schema;
             readonly diagnosticType: DiagnosticType;
             ecDefinition: Format;
-            messageArgs?: [Unit | InvertedUnit, string | undefined, string | undefined] | undefined;
+            messageArgs?: [InvertedUnit | Unit, string | undefined, string | undefined] | undefined;
             category: DiagnosticCategory;
         };
         diagnosticType: DiagnosticType;

common/api/ecschema-metadata.api.md

@@ -257,9 +257,7 @@ export abstract class ECClass extends SchemaItem implements CustomAttributeConta
     // (undocumented)
     protected addCustomAttribute(customAttribute: CustomAttribute): void;
     protected addProperty<T extends Property>(prop: T): T;
-    // (undocumented)
     get baseClass(): LazyLoadedECClass | undefined;
-    set baseClass(baseClass: LazyLoadedECClass | undefined);
     // (undocumented)
     protected _baseClass?: LazyLoadedECClass;
     // (undocumented)
@@ -293,6 +291,8 @@ export abstract class ECClass extends SchemaItem implements CustomAttributeConta
     // @alpha
     protected deletePropertySync(name: string): void;
     // (undocumented)
+    protected _derivedClasses?: Map<string, LazyLoadedECClass>;
+    // (undocumented)
     fromJSON(classProps: ClassProps): Promise<void>;
     // (undocumented)
     fromJSONSync(classProps: ClassProps): void;
@@ -303,6 +303,7 @@ export abstract class ECClass extends SchemaItem implements CustomAttributeConta
     getBaseClassSync(): ECClass | undefined;
     getCustomAttributes(): Promise<CustomAttributeSet>;
     getCustomAttributesSync(): CustomAttributeSet;
+    getDerivedClasses(): Promise<ECClass[] | undefined>;
     getInheritedProperty(name: string): Promise<Property | undefined>;
     getInheritedPropertySync(name: string): Property | undefined;
     getProperties(resetCache?: boolean): Promise<Property[]>;
@@ -333,6 +334,7 @@ export abstract class ECClass extends SchemaItem implements CustomAttributeConta
     get properties(): IterableIterator<Property> | undefined;
     // (undocumented)
     protected _properties?: Map<string, Property>;
+    setBaseClass(baseClass: LazyLoadedECClass | undefined): Promise<void>;
     // @alpha
     protected setModifier(modifier: ECClassModifier): void;
     toJSON(standalone?: boolean, includeSchemaVersion?: boolean): ClassProps;

common/changes/@itwin/ecschema-editing/derived-class-caching_2024-11-26-13-11.json

@@ -0,0 +1,10 @@
+{
+  "changes": [
+    {
+      "packageName": "@itwin/ecschema-editing",
+      "comment": "Replaced ECClass.baseClass setter with setBaseClass method due to underlying changes in the ecschema-metadata package.",
+      "type": "none"
+    }
+  ],
+  "packageName": "@itwin/ecschema-editing"
+}

common/changes/@itwin/ecschema-metadata/derived-class-caching_2024-11-26-13-11.json

@@ -0,0 +1,10 @@
+{
+  "changes": [
+    {
+      "packageName": "@itwin/ecschema-metadata",
+      "comment": "ECClass.baseClass setter has been replaced with setBaseClass method to enable derived class caching support.",
+      "type": "none"
+    }
+  ],
+  "packageName": "@itwin/ecschema-metadata"
+}

core/ecschema-editing/src/Editing/ECClasses.ts

@@ -66,7 +66,7 @@ export class ECClasses extends SchemaItems{
     if (baseClassKey !== undefined) {
       const baseClassSchema = !baseClassKey.schemaKey.matches(newClass.schema.schemaKey) ? await this.getSchema(baseClassKey.schemaKey) : newClass.schema as MutableSchema;
       const baseClassItem = await this.lookupSchemaItem<ECClass>(baseClassSchema, baseClassKey);
-      newClass.baseClass = new DelayedPromiseWithProps<SchemaItemKey, T>(baseClassKey, async () => baseClassItem as T);
+      await (newClass as ECClass as MutableClass).setBaseClass(new DelayedPromiseWithProps<SchemaItemKey, T>(baseClassKey, async () => baseClassItem as T));
     }
 
     return newClass;
@@ -275,7 +275,7 @@ export class ECClasses extends SchemaItems{
     try {
       const classItem = await this.getSchemaItem<ECClass>(itemKey);
       if (!baseClassKey) {
-        classItem.baseClass = undefined;
+        await (classItem as MutableClass).setBaseClass(undefined);
         return;
       }
 
@@ -284,7 +284,7 @@ export class ECClasses extends SchemaItems{
       if (classItem.baseClass !== undefined && !await baseClassItem.is(await classItem.baseClass))
         throw new SchemaEditingError(ECEditingStatus.InvalidBaseClass, new ClassId(this.schemaItemType, baseClassKey), undefined, undefined, `Base class ${baseClassKey.fullName} must derive from ${(await classItem.baseClass).fullName}.`);
 
-      classItem.baseClass = new DelayedPromiseWithProps<SchemaItemKey, ECClass>(baseClassKey, async () => baseClassItem);
+      await (classItem as MutableClass).setBaseClass(new DelayedPromiseWithProps<SchemaItemKey, ECClass>(baseClassKey, async () => baseClassItem));
     } catch(e: any) {
       throw new SchemaEditingError(ECEditingStatus.SetBaseClass, new ClassId(this.schemaItemType, itemKey), e);
     }

core/ecschema-editing/src/Editing/Mutable/MutableClass.ts

@@ -3,7 +3,7 @@
 * See LICENSE.md in the project root for license terms and full copyright notice.
 *--------------------------------------------------------------------------------------------*/
 import {
-  CustomAttribute, ECClass, ECClassModifier, Enumeration, EnumerationArrayProperty, EnumerationProperty, PrimitiveArrayProperty,
+  CustomAttribute, ECClass, ECClassModifier, Enumeration, EnumerationArrayProperty, EnumerationProperty, LazyLoadedECClass, PrimitiveArrayProperty,
   PrimitiveProperty, PrimitiveType, Property, StructArrayProperty, StructClass, StructProperty,
 } from "@itwin/ecschema-metadata";
 
@@ -20,6 +20,7 @@ export abstract class MutableStructClass extends StructClass {
  * @internal
  */
 export abstract class MutableClass extends ECClass {
+  public abstract override setBaseClass(baseClass: LazyLoadedECClass | undefined): Promise<void>;
   public abstract override addCustomAttribute(customAttribute: CustomAttribute): void;
   public abstract override setModifier(modifier: ECClassModifier): void;
   public abstract override setName(name: string): void;

core/ecschema-editing/src/Editing/RelationshipClasses.ts

@@ -7,7 +7,7 @@
  */
 
 import {
-  CustomAttribute, DelayedPromiseWithProps, ECClassModifier, EntityClass, LazyLoadedRelationshipConstraintClass, Mixin, NavigationPropertyProps,
+  CustomAttribute, DelayedPromiseWithProps, ECClass, ECClassModifier, EntityClass, LazyLoadedRelationshipConstraintClass, Mixin, NavigationPropertyProps,
   RelationshipClass, RelationshipClassProps, RelationshipConstraint, RelationshipEnd, RelationshipMultiplicity, SchemaItemKey, SchemaItemType,
   SchemaKey, StrengthDirection, StrengthType,
 } from "@itwin/ecschema-metadata";
@@ -18,6 +18,7 @@ import * as Rules from "../Validation/ECRules";
 import { AnyDiagnostic, RelationshipConstraintDiagnostic, SchemaItemDiagnostic } from "../Validation/Diagnostic";
 import { NavigationProperties } from "./Properties";
 import { ClassId, CustomAttributeId, ECEditingStatus, RelationshipConstraintId, SchemaEditingError } from "./Exception";
+import { MutableClass } from "./Mutable/MutableClass";
 
 /**
  * @alpha
@@ -107,15 +108,18 @@ export class RelationshipClasses extends ECClasses {
    * @param baseClassKey The SchemaItemKey of the base class. Specifying 'undefined' removes the base class.
    */
   public override async setBaseClass(itemKey: SchemaItemKey, baseClassKey?: SchemaItemKey): Promise<void> {
-    const relClass = await this.schemaEditor.schemaContext.getSchemaItem<RelationshipClass>(itemKey);
+    const relClass = await this.schemaEditor.schemaContext.getSchemaItem<RelationshipClass>(itemKey)
+      .catch((e) => {
+        throw new SchemaEditingError(ECEditingStatus.SetBaseClass, new ClassId(this.schemaItemType, itemKey), e);
+      });
     const baseClass = relClass?.baseClass;
 
     await super.setBaseClass(itemKey, baseClassKey);
 
     try {
       await this.validate(relClass!);
     } catch(e: any) {
-      relClass!.baseClass = baseClass;
+      await (relClass! as ECClass as MutableClass).setBaseClass(baseClass);
       throw new SchemaEditingError(ECEditingStatus.SetBaseClass, new ClassId(SchemaItemType.RelationshipClass, itemKey), e);
     }
   }

core/ecschema-editing/src/test/Editing/Entities.test.ts

@@ -60,8 +60,13 @@ describe("Entities tests", () => {
     const result = await testEditor.entities.create(testKey, "testEntity", ECClassModifier.None, "testLabel", testEntityBaseRes);
 
     const testEntity = await testEditor.schemaContext.getSchemaItem<EntityClass>(result);
-    expect(await testEntity?.baseClass).to.eql(await testEditor.schemaContext.getSchemaItem(testEntityBaseRes));
+    const baseEntity = await testEditor.schemaContext.getSchemaItem<EntityClass>(testEntityBaseRes);
+    expect(await testEntity?.baseClass).to.eql(baseEntity);
     expect(testEntity?.label).to.eql("testLabel");
+    const derivedClasses = await baseEntity?.getDerivedClasses();
+    expect(derivedClasses).to.not.be.undefined;
+    expect(derivedClasses![0]).to.eql(testEntity);
+    expect(derivedClasses?.length).to.eql(1);
   });
 
   it("should create a new entity class with a base class from different schema", async () => {
@@ -85,8 +90,13 @@ describe("Entities tests", () => {
     const result = await testEditor.entities.create(testKey, "testEntity", ECClassModifier.None, "testLabel", baseClassKey);
 
     const testEntity = await testEditor.schemaContext.getSchemaItem<EntityClass>(result);
+    const baseEntity = await testEditor.schemaContext.getSchemaItem<EntityClass>(baseClassKey);
     expect(await testEntity?.baseClass).to.eql(await testEditor.schemaContext.getSchemaItem(baseClassKey));
     expect(testEntity?.label).to.eql("testLabel");
+    const derivedClasses = await baseEntity?.getDerivedClasses();
+    expect(derivedClasses).to.not.be.undefined;
+    expect(derivedClasses![0]).to.eql(testEntity);
+    expect(derivedClasses?.length).to.eql(1);
   });
 
   it("try creating a new entity class with base class from unknown schema, returns error", async () => {
@@ -157,7 +167,12 @@ describe("Entities tests", () => {
     await testEditor.entities.setBaseClass(result, testEntityBaseRes);
 
     const testEntity = await testEditor.schemaContext.getSchemaItem<EntityClass>(result);
+    const baseEntity = await testEditor.schemaContext.getSchemaItem<EntityClass>(testEntityBaseRes);
     expect(await testEntity?.baseClass).to.eql(await testEditor.schemaContext.getSchemaItem(testEntityBaseRes));
+    const derivedClasses = await baseEntity?.getDerivedClasses();
+    expect(derivedClasses).to.not.be.undefined;
+    expect(derivedClasses![0]).to.eql(testEntity);
+    expect(derivedClasses?.length).to.eql(1);
   });
 
   it("should add base class to existing entity class where base class is from a different schema", async () => {
@@ -182,7 +197,12 @@ describe("Entities tests", () => {
     await testEditor.entities.setBaseClass(result, baseClassKey);
 
     const testEntity = await testEditor.schemaContext.getSchemaItem<EntityClass>(result);
+    const baseEntity = await testEditor.schemaContext.getSchemaItem<EntityClass>(baseClassKey);
     expect(await testEntity?.baseClass).to.eql(await testEditor.schemaContext.getSchemaItem(baseClassKey));
+    const derivedClasses = await baseEntity?.getDerivedClasses();
+    expect(derivedClasses).to.not.be.undefined;
+    expect(derivedClasses![0]).to.eql(testEntity);
+    expect(derivedClasses?.length).to.eql(1);
   });
 
   it("should change base class of existing entity class with different base class.", async () => {
@@ -215,8 +235,13 @@ describe("Entities tests", () => {
     expect(await testEntity?.baseClass).to.eql(await testEditor.schemaContext.getSchemaItem(firstBaseClassKey));
 
     const secondBaseClassKey = new SchemaItemKey("testEntityBase2", refSchema.schemaKey);
+    const secondBaseClass = await testEditor.schemaContext.getSchemaItem<EntityClass>(secondBaseClassKey);
     await testEditor.entities.setBaseClass(testEntityResult, secondBaseClassKey);
     expect(await testEntity?.baseClass).to.eql(await testEditor.schemaContext.getSchemaItem(secondBaseClassKey));
+    const derivedClasses = await secondBaseClass?.getDerivedClasses();
+    expect(derivedClasses).to.not.be.undefined;
+    expect(derivedClasses![0]).to.eql(testEntity);
+    expect(derivedClasses?.length).to.eql(1);
   });
 
   it("should remove base class from existing entity class.", async () => {
@@ -228,6 +253,9 @@ describe("Entities tests", () => {
 
     await testEditor.entities.setBaseClass(result, undefined);
     expect(await testEntity?.baseClass).to.eql(undefined);
+    const baseEntity = await testEditor.schemaContext.getSchemaItem<EntityClass>(testEntityBaseRes);
+    const derivedClasses = await baseEntity?.getDerivedClasses();
+    expect(derivedClasses).to.be.undefined;
   });
 
   it("try adding base class with unknown schema to existing entity class, returns error", async () => {

core/ecschema-editing/src/test/Validation/ECRules/ClassRules.test.ts

@@ -4,11 +4,12 @@
 *--------------------------------------------------------------------------------------------*/
 
 import { expect } from "chai";
-import { DelayedPromiseWithProps, ECClassModifier, EntityClass,
+import { DelayedPromiseWithProps, ECClass, ECClassModifier, EntityClass,
   RelationshipClass, Schema, SchemaContext, schemaItemTypeToString,
 } from "@itwin/ecschema-metadata";
 import * as Rules from "../../../Validation/ECRules";
 import { DiagnosticCategory, DiagnosticType } from "../../../Validation/Diagnostic";
+import { MutableClass } from "../../../Editing/Mutable/MutableClass";
 
 /* eslint-disable @typescript-eslint/no-deprecated */
 
@@ -22,7 +23,7 @@ describe("ClassRule tests", () => {
   it("BaseClassIsSealed, rule violated.", async () => {
     const baseClass = new EntityClass(schema, "TestBase", ECClassModifier.Sealed);
     const entityClass = new EntityClass(schema, "TestClass");
-    entityClass.baseClass = new DelayedPromiseWithProps(baseClass.key, async () => baseClass);
+    await (entityClass as ECClass as MutableClass).setBaseClass(new DelayedPromiseWithProps(baseClass.key, async () => baseClass));
 
     const result = Rules.baseClassIsSealed(entityClass);
 
@@ -42,7 +43,7 @@ describe("ClassRule tests", () => {
   it("BaseClassIsSealed, base is not sealed, rule passes.", async () => {
     const baseClass = new EntityClass(schema, "TestBase");
     const entityClass = new EntityClass(schema, "TestClass");
-    entityClass.baseClass = new DelayedPromiseWithProps(baseClass.key, async () => baseClass);
+    await (entityClass as ECClass as MutableClass).setBaseClass(new DelayedPromiseWithProps(baseClass.key, async () => baseClass));
 
     const result = Rules.baseClassIsSealed(entityClass);
     for await (const _diagnostic of result) {
@@ -62,7 +63,7 @@ describe("ClassRule tests", () => {
   it("BaseClassIsOfDifferentType, rule violated.", async () => {
     const baseClass = new RelationshipClass(schema, "TestBase");
     const entityClass = new EntityClass(schema, "TestClass");
-    entityClass.baseClass = new DelayedPromiseWithProps(baseClass.key, async () => baseClass);
+    await (entityClass as ECClass as MutableClass).setBaseClass(new DelayedPromiseWithProps(baseClass.key, async () => baseClass));
     const baseType = schemaItemTypeToString(baseClass.schemaItemType);
 
     const result = Rules.baseClassIsOfDifferentType(entityClass);
@@ -82,7 +83,7 @@ describe("ClassRule tests", () => {
   it("BaseClassIsOfDifferentType, same type, rule passes.", async () => {
     const baseClass = new EntityClass(schema, "TestBase");
     const entityClass = new EntityClass(schema, "TestClass");
-    entityClass.baseClass = new DelayedPromiseWithProps(baseClass.key, async () => baseClass);
+    await (entityClass as ECClass as MutableClass).setBaseClass(new DelayedPromiseWithProps(baseClass.key, async () => baseClass));
 
     const result = Rules.baseClassIsOfDifferentType(entityClass);
     for await (const _diagnostic of result) {

core/ecschema-editing/src/test/Validation/ECRules/MixinRules.test.ts

@@ -4,10 +4,11 @@
 *--------------------------------------------------------------------------------------------*/
 
 import { expect } from "chai";
-import { DelayedPromiseWithProps, EntityClass, Mixin, Schema, SchemaContext } from "@itwin/ecschema-metadata";
+import { DelayedPromiseWithProps, ECClass, EntityClass, Mixin, Schema, SchemaContext } from "@itwin/ecschema-metadata";
 import { MutableEntityClass } from "../../../Editing/Mutable/MutableEntityClass";
 import { DiagnosticCategory, DiagnosticType } from "../../../Validation/Diagnostic";
 import * as Rules from "../../../Validation/ECRules";
+import { MutableClass } from "../../../Editing/Mutable/MutableClass";
 
 describe("Mixin Rule Tests", () => {
   let schema: Schema;
@@ -28,7 +29,7 @@ describe("Mixin Rule Tests", () => {
     const mixin = new TestMixin(schema, "TestMixin", constraintClass);
     const entityClass = new EntityClass(schema, "TestClass");
     (entityClass as MutableEntityClass).addMixin(mixin);
-    entityClass.baseClass = new DelayedPromiseWithProps(constraintClass.key, async () => constraintClass);
+    await (entityClass as ECClass as MutableClass).setBaseClass(new DelayedPromiseWithProps(constraintClass.key, async () => constraintClass));
 
     const result = Rules.mixinAppliedToClassMustDeriveFromConstraint(entityClass);
     for await (const _diagnostic of result) {
@@ -73,7 +74,7 @@ describe("Mixin Rule Tests", () => {
     const mixin = new TestMixin(schema, "TestMixin", constraintClass);
     const entityClass = new EntityClass(schema, "TestClass");
     (entityClass as MutableEntityClass).addMixin(mixin);
-    entityClass.baseClass = new DelayedPromiseWithProps(baseClass.key, async () => baseClass);
+    await (entityClass as ECClass as MutableClass).setBaseClass(new DelayedPromiseWithProps(baseClass.key, async () => baseClass));
 
     const result = Rules.mixinAppliedToClassMustDeriveFromConstraint(entityClass);