@itwin/ecschema-editing 4.6.0-dev.6 → 4.6.0-dev.8

package/lib/cjs/Merging/SchemaItemMerger.js

@@ -1,102 +1,120 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchemaItemMerger = void 0;
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
+exports.updateSchemaItemKey = exports.updateSchemaItemFullName = exports.mergeSchemaItems = exports.locateSchemaItem = void 0;
+const SchemaDifference_1 = require("../Differencing/SchemaDifference");
 const ecschema_metadata_1 = require("@itwin/ecschema-metadata");
-const SchemaChanges_1 = require("../Validation/SchemaChanges");
-const SchemaItemFactory_1 = require("./SchemaItemFactory");
+const EnumerationMerger_1 = require("./EnumerationMerger");
+const PhenomenonMerger_1 = require("./PhenomenonMerger");
+const PropertyCategoryMerger_1 = require("./PropertyCategoryMerger");
+const UnitSystemMerger_1 = require("./UnitSystemMerger");
+const KindOfQuantityMerger_1 = require("./KindOfQuantityMerger");
+const ConstantMerger_1 = require("./ConstantMerger");
+const ClassMerger_1 = require("./ClassMerger");
 /**
- * The SchemaItemMerger is an base class for several other mergers with the actual logic
- * to perform merging for a certain schema item type. The class provides the shared logics
- * that is shared for all schema item mergers and custom logic can be applied by overriding
- * the protected class members.
+ * Handles the merging logic for everything that is same for all schema items such as labels or descriptions
  * @internal
  */
-class SchemaItemMerger {
-    /**
-     * Constructor of the SchemaItemMerger class. This should not be overriden or extended
-     * by sub-implementations.
-     * @param context   The current merging context.
-     */
-    constructor(context) {
-        this.context = context;
+async function mergeSchemaItem(context, change, merger) {
+    if (change.changeType === "add") {
+        return merger.add(context, change);
     }
-    /**
-     * This overridable method allows to create a property value resolver that gets defines
-     * a handler function for every possible property change. This allows adding complex handing
-     * if a property value requires complicated merging.
-     * @returns   A resolver map with resolvers for the property.
-     */
-    async createPropertyValueResolver() {
-        // Can be overriden for complex property value merging
-        return {};
+    if (change.changeType === "modify") {
+        const schemaItem = await locateSchemaItem(context, change.itemName, change.schemaType);
+        return merger.modify(context, change, schemaItem.key, schemaItem);
     }
-    /**
-     * This overridable method gets called for more complex merging.
-     * @param _itemKey  The key of the current schema item.
-     * @param _source   The source item that shall gets merged into.
-     * @param _change   The schema item change to be applied.
-     */
-    async merge(_itemKey, _source, _change) {
-        // Can be overriden for complex merging
+    return { errorMessage: `The merger does not support ${change.changeType} of ${change.schemaType}.` };
+}
+/**
+ * @internal
+ */
+async function locateSchemaItem(context, itemName, schemaType) {
+    const schemaItemKey = new ecschema_metadata_1.SchemaItemKey(itemName, context.targetSchemaKey);
+    const schemaItem = await context.editor.schemaContext.getSchemaItem(schemaItemKey);
+    if (schemaItem === undefined) {
+        throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.ClassNotFound, `${schemaType} ${schemaItemKey.fullName} not found in schema context.`);
+    }
+    return schemaItem;
+}
+exports.locateSchemaItem = locateSchemaItem;
+/**
+ * Merges the given set of schema items. As schema items may depend or relate with other
+ * schema items, the list gets filtered to ensure the items get merged in a certain order.
+ * @param context       The current merging context.
+ * @param itemChanges   Set of schema item that differed.
+ * @returns             An async iterable with the merge result for each schema item.
+ * @internal
+ */
+async function* mergeSchemaItems(context, itemChanges) {
+    for (const difference of itemChanges.filter(SchemaDifference_1.SchemaDifference.isUnitSystemDifference)) {
+        yield await mergeSchemaItem(context, difference, UnitSystemMerger_1.unitSystemMerger);
+    }
+    for (const difference of itemChanges.filter(SchemaDifference_1.SchemaDifference.isPropertyCategoryDifference)) {
+        yield await mergeSchemaItem(context, difference, PropertyCategoryMerger_1.propertyCategoryMerger);
+    }
+    for (const difference of itemChanges.filter(SchemaDifference_1.SchemaDifference.isEnumerationDifference)) {
+        yield await mergeSchemaItem(context, difference, EnumerationMerger_1.enumerationMerger);
+    }
+    for (const difference of itemChanges.filter(SchemaDifference_1.SchemaDifference.isEnumeratorDifference)) {
+        yield await mergeSchemaItem(context, difference, EnumerationMerger_1.enumeratorMerger);
+    }
+    for (const difference of itemChanges.filter(SchemaDifference_1.SchemaDifference.isPhenomenonDifference)) {
+        yield await mergeSchemaItem(context, difference, PhenomenonMerger_1.phenomenonMerger);
+    }
+    // TODO:
+    // The following schema items are not supported yet. Mentioned in the processing order:
+    // - Unit
+    // - Inverted Unit
+    // - Format
+    for (const difference of itemChanges.filter(SchemaDifference_1.SchemaDifference.isKindOfQuantityDifference)) {
+        yield await mergeSchemaItem(context, difference, KindOfQuantityMerger_1.kindOfQuantityMerger);
     }
-    async lookup(schemaItem) {
-        const itemKey = new ecschema_metadata_1.SchemaItemKey(schemaItem.name, this.context.sourceSchema.schemaKey.matches(schemaItem.schema.schemaKey)
-            ? this.context.targetSchema.schemaKey
-            : schemaItem.schema.schemaKey);
-        return this.context.targetSchema.lookupItem(itemKey);
+    for (const difference of itemChanges.filter(SchemaDifference_1.SchemaDifference.isConstantDifference)) {
+        yield await mergeSchemaItem(context, difference, ConstantMerger_1.constantMerger);
     }
-    /**
-     * Merges the given schema item changes in the current context.
-     * @param context             The merging context
-     * @param schemaItemChanges   An iterable of item changes.
-     */
-    static async mergeChanges(context, schemaItemChanges) {
-        const merger = new this(context);
-        for (const change of schemaItemChanges) {
-            // Gets the source and the target item. The target item could be undefined at that point.
-            const sourceItem = (await context.sourceSchema.getItem(change.ecTypeName));
-            let targetItemKey = new ecschema_metadata_1.SchemaItemKey(change.ecTypeName, context.targetSchema.schemaKey);
-            // In case the schema item does not exists in the target schema, an instance for
-            // this schema item is created. It's properties get set by the merger then.
-            if (change.schemaItemMissing?.changeType === SchemaChanges_1.ChangeType.Missing) {
-                // Check for name to make sure there is no collision for items with the same name
-                // but different type.
-                if (await context.targetSchema.lookupItem(targetItemKey) !== undefined) {
-                    throw new Error(`Schema ${context.targetSchema.name} already contains a Schema Item ${change.ecTypeName}.`);
-                }
-                // TODO: Think about renaming the Schema Item. This could be controlled though a flag.
-                targetItemKey = await SchemaItemFactory_1.SchemaItemFactory.create(context, sourceItem);
-            }
-            await merger.mergeItemPropertyValues(targetItemKey, change.propertyValueChanges);
-            await merger.merge(targetItemKey, sourceItem, change);
-        }
+    // Classes are slightly differently merged, since they can refer each other the process
+    // uses several stages to merge.
+    for await (const classMergeResult of (0, ClassMerger_1.mergeClassItems)(context, itemChanges)) {
+        yield classMergeResult;
     }
-    /**
-     * Merges the property values.
-     * @param targetItem  The current schema item
-     * @param changes     The property changes.
-     */
-    async mergeItemPropertyValues(targetItemKey, changes) {
-        // No need to process anything if no properties differ.
-        if (changes.length === 0) {
-            return;
-        }
-        const targetItem = (await this.context.targetSchema.lookupItem(targetItemKey));
-        const jsonProps = (targetItem?.toJSON() ?? {});
-        const propertyResolver = await this.createPropertyValueResolver();
-        for (const change of changes) {
-            const [propertyName, propertyNewValue, propertyOldValue] = change.diagnostic.messageArgs;
-            const resolver = propertyResolver[propertyName];
-            jsonProps[propertyName] = resolver !== undefined
-                ? resolver(propertyNewValue, targetItemKey, propertyOldValue)
-                : propertyNewValue;
-        }
-        await this.context.editor.schemaItems.applyProps(targetItemKey, jsonProps);
+}
+exports.mergeSchemaItems = mergeSchemaItems;
+/**
+ * Convenience-method around updateSchemaItemKey that returns the full name instead of a SchemaItemKey.
+ * @internal
+ */
+async function updateSchemaItemFullName(context, reference) {
+    const schemaItemKey = await updateSchemaItemKey(context, reference);
+    return schemaItemKey.fullName;
+}
+exports.updateSchemaItemFullName = updateSchemaItemFullName;
+/**
+ * Updates the given reference if it refers to a SchemaItem in the source Schema and
+ * returns a SchemaItemKey. If any other schema is referred the reference is not change.
+ * @internal
+ */
+async function updateSchemaItemKey(context, reference) {
+    const [schemaName, itemName] = ecschema_metadata_1.SchemaItem.parseFullName(reference);
+    if (context.sourceSchemaKey.compareByName(schemaName)) {
+        return resolveSchemaItemKey(context.editor.schemaContext, new ecschema_metadata_1.SchemaItemKey(itemName, context.targetSchemaKey));
+    }
+    const referencedSchema = await context.targetSchema.getReference(schemaName);
+    if (referencedSchema !== undefined) {
+        return resolveSchemaItemKey(context.editor.schemaContext, new ecschema_metadata_1.SchemaItemKey(itemName, referencedSchema.schemaKey));
+    }
+    throw new Error(`Cannot locate referenced schema item ${reference}`);
+}
+exports.updateSchemaItemKey = updateSchemaItemKey;
+/**
+ * To support case insensitivity for schema items, the given key is checked if there
+ * exists an item for it.
+ * @internal
+ */
+async function resolveSchemaItemKey(schemaContext, itemKey) {
+    const item = await schemaContext.getSchemaItem(itemKey);
+    if (item === undefined) {
+        // If the schema item hasn't been created yet, we have to trust the given key is correctly spelled.
+        return itemKey;
     }
+    return item.key;
 }
-exports.SchemaItemMerger = SchemaItemMerger;
 //# sourceMappingURL=SchemaItemMerger.js.map

package/lib/cjs/Merging/SchemaItemMerger.js.map

@@ -1 +1 @@
-{"version":3,"file":"SchemaItemMerger.js","sourceRoot":"","sources":["../../../src/Merging/SchemaItemMerger.ts"],"names":[],"mappings":";;;AAAA;;;+FAG+F;AAC/F,gEAAqE;AACrE,+DAAiG;AACjG,2DAAwD;AAkBxD;;;;;;GAMG;AACH,MAAa,gBAAgB;IAI3B;;;;OAIG;IACH,YAAY,OAA2B;QACrC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IACzB,CAAC;IAED;;;;;OAKG;IACO,KAAK,CAAC,2BAA2B;QACzC,sDAAsD;QACtD,OAAO,EAAE,CAAC;IACZ,CAAC;IAED;;;;;OAKG;IACO,KAAK,CAAC,KAAK,CAAC,QAAuB,EAAE,OAAc,EAAE,OAA0B;QACvF,uCAAuC;IACzC,CAAC;IAES,KAAK,CAAC,MAAM,CAAuB,UAAa;QACxD,MAAM,OAAO,GAAG,IAAI,iCAAa,CAAC,UAAU,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,SAAS,CAAC,OAAO,CAAC,UAAU,CAAC,MAAM,CAAC,SAAS,CAAC;YACzH,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,SAAS;YACrC,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC,SAAS,CAC9B,CAAC;QACF,OAAO,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,UAAU,CAAI,OAAO,CAAC,CAAC;IAC1D,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,KAAK,CAAC,YAAY,CAAoC,OAA2B,EAAE,iBAAoC;QACnI,MAAM,MAAM,GAAG,IAAI,IAAI,CAAC,OAAO,CAAC,CAAC;QACjC,KAAI,MAAM,MAAM,IAAI,iBAAiB,EAAE;YAErC,yFAAyF;YACzF,MAAM,UAAU,GAAG,CAAC,MAAM,OAAO,CAAC,YAAY,CAAC,OAAO,CAAa,MAAM,CAAC,UAAU,CAAC,CAAE,CAAC;YACxF,IAAI,aAAa,GAAG,IAAI,iCAAa,CAAC,MAAM,CAAC,UAAU,EAAE,OAAO,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;YAEzF,gFAAgF;YAChF,2EAA2E;YAC3E,IAAG,MAAM,CAAC,iBAAiB,EAAE,UAAU,KAAK,0BAAU,CAAC,OAAO,EAAE;gBAC9D,iFAAiF;gBACjF,sBAAsB;gBACtB,IAAG,MAAM,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,aAAa,CAAC,KAAK,SAAS,EAAE;oBACrE,MAAM,IAAI,KAAK,CAAC,UAAU,OAAO,CAAC,YAAY,CAAC,IAAI,mCAAmC,MAAM,CAAC,UAAU,GAAG,CAAC,CAAC;iBAC7G;gBAED,sFAAsF;gBACtF,aAAa,GAAG,MAAM,qCAAiB,CAAC,MAAM,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;aACrE;YAED,MAAM,MAAM,CAAC,uBAAuB,CAAC,aAAa,EAAE,MAAM,CAAC,oBAAoB,CAAC,CAAC;YACjF,MAAM,MAAM,CAAC,KAAK,CAAC,aAAa,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;SACvD;IACH,CAAC;IACD;;;;OAIG;IACK,KAAK,CAAC,uBAAuB,CAAC,aAA4B,EAAE,OAA8B;QAChG,uDAAuD;QACvD,IAAG,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE;YACvB,OAAO;SACR;QAED,MAAM,UAAU,GAAG,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,UAAU,CAAa,aAAa,CAAC,CAAC,CAAC;QAC3F,MAAM,SAAS,GAAG,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,CAAkC,CAAC;QAChF,MAAM,gBAAgB,GAAG,MAAM,IAAI,CAAC,2BAA2B,EAAE,CAAC;QAElE,KAAI,MAAM,MAAM,IAAI,OAAO,EAAE;YAC3B,MAAM,CAAC,YAAY,EAAE,gBAAgB,EAAE,gBAAgB,CAAC,GAAG,MAAM,CAAC,UAAU,CAAC,WAAkD,CAAC;YAChI,MAAM,QAAQ,GAAG,gBAAgB,CAAC,YAAY,CAAC,CAAC;YAChD,SAAS,CAAC,YAAY,CAAC,GAAG,QAAQ,KAAK,SAAS;gBAC9C,CAAC,CAAC,QAAQ,CAAC,gBAAgB,EAAE,aAAa,EAAE,gBAAgB,CAAC;gBAC7D,CAAC,CAAC,gBAAgB,CAAC;SACtB;QAED,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC,UAAU,CAAC,aAAa,EAAE,SAAS,CAAC,CAAC;IAC7E,CAAC;CACF;AAjGD,4CAiGC","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\nimport { SchemaItem, SchemaItemKey } from \"@itwin/ecschema-metadata\";\r\nimport { ChangeType, PropertyValueChange, SchemaItemChanges } from \"../Validation/SchemaChanges\";\r\nimport { SchemaItemFactory } from \"./SchemaItemFactory\";\r\nimport { SchemaMergeContext } from \"./SchemaMerger\";\r\n\r\n/**\r\n * Defines a type-safe interface of Property Value resolver.\r\n * @internal\r\n */\r\nexport type PropertyValueResolver<T extends SchemaItem, TProps=MutableSchemaItemProps<T>> = {\r\n  [P in keyof TProps]?: (newValue: any, item: SchemaItemKey, oldValue?: any) => any;\r\n};\r\n\r\n/**\r\n * Defines a Mutable Schema Props interface.\r\n */\r\ntype MutableSchemaItemProps<T extends SchemaItem> = {\r\n  -readonly [key in keyof ReturnType<T[\"toJSON\"]>]: ReturnType<T[\"toJSON\"]>[key];\r\n};\r\n\r\n/**\r\n * The SchemaItemMerger is an base class for several other mergers with the actual logic\r\n * to perform merging for a certain schema item type. The class provides the shared logics\r\n * that is shared for all schema item mergers and custom logic can be applied by overriding\r\n * the protected class members.\r\n * @internal\r\n */\r\nexport class SchemaItemMerger<TItem extends SchemaItem> {\r\n\r\n  protected readonly context: SchemaMergeContext;\r\n\r\n  /**\r\n   * Constructor of the SchemaItemMerger class. This should not be overriden or extended\r\n   * by sub-implementations.\r\n   * @param context   The current merging context.\r\n   */\r\n  constructor(context: SchemaMergeContext) {\r\n    this.context = context;\r\n  }\r\n\r\n  /**\r\n   * This overridable method allows to create a property value resolver that gets defines\r\n   * a handler function for every possible property change. This allows adding complex handing\r\n   * if a property value requires complicated merging.\r\n   * @returns   A resolver map with resolvers for the property.\r\n   */\r\n  protected async createPropertyValueResolver(): Promise<PropertyValueResolver<TItem>> {\r\n    // Can be overriden for complex property value merging\r\n    return {};\r\n  }\r\n\r\n  /**\r\n   * This overridable method gets called for more complex merging.\r\n   * @param _itemKey  The key of the current schema item.\r\n   * @param _source   The source item that shall gets merged into.\r\n   * @param _change   The schema item change to be applied.\r\n   */\r\n  protected async merge(_itemKey: SchemaItemKey, _source: TItem, _change: SchemaItemChanges) {\r\n    // Can be overriden for complex merging\r\n  }\r\n\r\n  protected async lookup<T extends SchemaItem>(schemaItem: T): Promise<T | undefined>{\r\n    const itemKey = new SchemaItemKey(schemaItem.name, this.context.sourceSchema.schemaKey.matches(schemaItem.schema.schemaKey)\r\n      ? this.context.targetSchema.schemaKey\r\n      : schemaItem.schema.schemaKey,\r\n    );\r\n    return this.context.targetSchema.lookupItem<T>(itemKey);\r\n  }\r\n\r\n  /**\r\n   * Merges the given schema item changes in the current context.\r\n   * @param context             The merging context\r\n   * @param schemaItemChanges   An iterable of item changes.\r\n   */\r\n  public static async mergeChanges<TChange extends SchemaItemChanges>(context: SchemaMergeContext, schemaItemChanges: Iterable<TChange>) {\r\n    const merger = new this(context);\r\n    for(const change of schemaItemChanges) {\r\n\r\n      // Gets the source and the target item. The target item could be undefined at that point.\r\n      const sourceItem = (await context.sourceSchema.getItem<SchemaItem>(change.ecTypeName))!;\r\n      let targetItemKey = new SchemaItemKey(change.ecTypeName, context.targetSchema.schemaKey);\r\n\r\n      // In case the schema item does not exists in the target schema, an instance for\r\n      // this schema item is created. It's properties get set by the merger then.\r\n      if(change.schemaItemMissing?.changeType === ChangeType.Missing) {\r\n        // Check for name to make sure there is no collision for items with the same name\r\n        // but different type.\r\n        if(await context.targetSchema.lookupItem(targetItemKey) !== undefined) {\r\n          throw new Error(`Schema ${context.targetSchema.name} already contains a Schema Item ${change.ecTypeName}.`);\r\n        }\r\n\r\n        // TODO: Think about renaming the Schema Item. This could be controlled though a flag.\r\n        targetItemKey = await SchemaItemFactory.create(context, sourceItem);\r\n      }\r\n\r\n      await merger.mergeItemPropertyValues(targetItemKey, change.propertyValueChanges);\r\n      await merger.merge(targetItemKey, sourceItem, change);\r\n    }\r\n  }\r\n  /**\r\n   * Merges the property values.\r\n   * @param targetItem  The current schema item\r\n   * @param changes     The property changes.\r\n   */\r\n  private async mergeItemPropertyValues(targetItemKey: SchemaItemKey, changes: PropertyValueChange[]) {\r\n    // No need to process anything if no properties differ.\r\n    if(changes.length === 0) {\r\n      return;\r\n    }\r\n\r\n    const targetItem = (await this.context.targetSchema.lookupItem<SchemaItem>(targetItemKey));\r\n    const jsonProps = (targetItem?.toJSON() ?? {}) as MutableSchemaItemProps<TItem>;\r\n    const propertyResolver = await this.createPropertyValueResolver();\r\n\r\n    for(const change of changes) {\r\n      const [propertyName, propertyNewValue, propertyOldValue] = change.diagnostic.messageArgs! as [keyof typeof jsonProps, any, any];\r\n      const resolver = propertyResolver[propertyName];\r\n      jsonProps[propertyName] = resolver !== undefined\r\n        ? resolver(propertyNewValue, targetItemKey, propertyOldValue)\r\n        : propertyNewValue;\r\n    }\r\n\r\n    await this.context.editor.schemaItems.applyProps(targetItemKey, jsonProps);\r\n  }\r\n}\r\n"]}
+{"version":3,"file":"SchemaItemMerger.js","sourceRoot":"","sources":["../../../src/Merging/SchemaItemMerger.ts"],"names":[],"mappings":"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","sourcesContent":["/*---------------------------------------------------------------------------------------------\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\n* See LICENSE.md in the project root for license terms and full copyright notice.\n*--------------------------------------------------------------------------------------------*/\nimport type { SchemaMergeContext } from \"./SchemaMerger\";\nimport type { SchemaEditResults, SchemaItemEditResults } from \"../Editing/Editor\";\nimport { AnySchemaDifference, AnySchemaItemDifference, AnySchemaItemPathDifference, SchemaDifference } from \"../Differencing/SchemaDifference\";\nimport { ECObjectsError, ECObjectsStatus, SchemaContext, SchemaItem, SchemaItemKey } from \"@itwin/ecschema-metadata\";\nimport { enumerationMerger, enumeratorMerger } from \"./EnumerationMerger\";\nimport { phenomenonMerger } from \"./PhenomenonMerger\";\nimport { propertyCategoryMerger } from \"./PropertyCategoryMerger\";\nimport { unitSystemMerger } from \"./UnitSystemMerger\";\nimport { kindOfQuantityMerger } from \"./KindOfQuantityMerger\";\nimport { constantMerger } from \"./ConstantMerger\";\nimport { mergeClassItems } from \"./ClassMerger\";\n\n/**\n * @internal\n */\nexport interface SchemaItemMergerHandler<T extends AnySchemaItemDifference | AnySchemaItemPathDifference> {\n  add:    (context: SchemaMergeContext, change: T) => Promise<SchemaItemEditResults>;\n  modify: (context: SchemaMergeContext, change: T, itemKey: SchemaItemKey, item: any) => Promise<SchemaItemEditResults>;\n}\n\n/**\n * Handles the merging logic for everything that is same for all schema items such as labels or descriptions\n * @internal\n */\nasync function mergeSchemaItem<T extends AnySchemaItemDifference|AnySchemaItemPathDifference>(context: SchemaMergeContext, change: T, merger: SchemaItemMergerHandler<T>): Promise<SchemaEditResults> {\n  if(change.changeType === \"add\") {\n    return merger.add(context, change);\n  }\n\n  if(change.changeType === \"modify\") {\n    const schemaItem = await locateSchemaItem(context, change.itemName, change.schemaType);\n    return merger.modify(context, change, schemaItem.key, schemaItem);\n  }\n\n  return { errorMessage: `The merger does not support ${change.changeType} of ${change.schemaType}.` };\n}\n\n/**\n * @internal\n */\nexport async function locateSchemaItem(context: SchemaMergeContext, itemName: string, schemaType: string) {\n  const schemaItemKey = new SchemaItemKey(itemName, context.targetSchemaKey);\n  const schemaItem = await context.editor.schemaContext.getSchemaItem(schemaItemKey);\n  if (schemaItem === undefined) {\n    throw new ECObjectsError(ECObjectsStatus.ClassNotFound, `${schemaType} ${schemaItemKey.fullName} not found in schema context.`);\n  }\n\n  return schemaItem;\n}\n\n/**\n * Merges the given set of schema items. As schema items may depend or relate with other\n * schema items, the list gets filtered to ensure the items get merged in a certain order.\n * @param context       The current merging context.\n * @param itemChanges   Set of schema item that differed.\n * @returns             An async iterable with the merge result for each schema item.\n * @internal\n */\nexport async function* mergeSchemaItems(context: SchemaMergeContext, itemChanges: AnySchemaDifference[]) {\n  for (const difference of itemChanges.filter(SchemaDifference.isUnitSystemDifference)) {\n    yield await mergeSchemaItem(context, difference, unitSystemMerger);\n  }\n\n  for (const difference of itemChanges.filter(SchemaDifference.isPropertyCategoryDifference)) {\n    yield await mergeSchemaItem(context, difference, propertyCategoryMerger);\n  }\n\n  for (const difference of itemChanges.filter(SchemaDifference.isEnumerationDifference)) {\n    yield await mergeSchemaItem(context, difference, enumerationMerger);\n  }\n\n  for (const difference of itemChanges.filter(SchemaDifference.isEnumeratorDifference)) {\n    yield await mergeSchemaItem(context, difference, enumeratorMerger);\n  }\n\n  for (const difference of itemChanges.filter(SchemaDifference.isPhenomenonDifference)) {\n    yield await mergeSchemaItem(context, difference, phenomenonMerger);\n  }\n\n  // TODO:\n  // The following schema items are not supported yet. Mentioned in the processing order:\n  // - Unit\n  // - Inverted Unit\n  // - Format\n\n  for (const difference of itemChanges.filter(SchemaDifference.isKindOfQuantityDifference)) {\n    yield await mergeSchemaItem(context, difference, kindOfQuantityMerger);\n  }\n\n  for (const difference of itemChanges.filter(SchemaDifference.isConstantDifference)) {\n    yield await mergeSchemaItem(context, difference, constantMerger);\n  }\n\n  // Classes are slightly differently merged, since they can refer each other the process\n  // uses several stages to merge.\n  for await (const classMergeResult of mergeClassItems(context, itemChanges)) {\n    yield classMergeResult;\n  }\n}\n\n/**\n * Convenience-method around updateSchemaItemKey that returns the full name instead of a SchemaItemKey.\n * @internal\n */\nexport async function updateSchemaItemFullName(context: SchemaMergeContext, reference: string) {\n  const schemaItemKey = await updateSchemaItemKey(context, reference);\n  return schemaItemKey.fullName;\n}\n\n/**\n * Updates the given reference if it refers to a SchemaItem in the source Schema and\n * returns a SchemaItemKey. If any other schema is referred the reference is not change.\n * @internal\n */\nexport async function updateSchemaItemKey(context: SchemaMergeContext, reference: string) {\n  const [schemaName, itemName] = SchemaItem.parseFullName(reference);\n  if (context.sourceSchemaKey.compareByName(schemaName)) {\n    return resolveSchemaItemKey(context.editor.schemaContext, new SchemaItemKey(itemName, context.targetSchemaKey));\n  }\n\n  const referencedSchema = await context.targetSchema.getReference(schemaName);\n  if (referencedSchema !== undefined) {\n    return resolveSchemaItemKey(context.editor.schemaContext, new SchemaItemKey(itemName, referencedSchema.schemaKey));\n  }\n\n  throw new Error(`Cannot locate referenced schema item ${reference}`);\n}\n\n/**\n * To support case insensitivity for schema items, the given key is checked if there\n * exists an item for it.\n * @internal\n */\nasync function resolveSchemaItemKey(schemaContext: SchemaContext, itemKey: SchemaItemKey): Promise<SchemaItemKey> {\n  const item = await schemaContext.getSchemaItem(itemKey);\n  if (item === undefined) {\n    // If the schema item hasn't been created yet, we have to trust the given key is correctly spelled.\n    return itemKey;\n  }\n  return item.key;\n}\n"]}

package/lib/cjs/Merging/SchemaMerger.d.ts

@@ -1,15 +1,17 @@
 /** @packageDocumentation
  * @module Merging
  */
-import { Schema } from "@itwin/ecschema-metadata";
+import { Schema, type SchemaContext, SchemaKey } from "@itwin/ecschema-metadata";
 import { SchemaContextEditor } from "../Editing/Editor";
+import { SchemaDifferences } from "../Differencing/SchemaDifference";
 /**
  * Defines the context of a Schema merging run.
  * @beta
  */
 export interface SchemaMergeContext {
     readonly targetSchema: Schema;
-    readonly sourceSchema: Schema;
+    readonly targetSchemaKey: SchemaKey;
+    readonly sourceSchemaKey: SchemaKey;
     readonly editor: SchemaContextEditor;
 }
 /**
@@ -18,15 +20,12 @@ export interface SchemaMergeContext {
  * @beta
  */
 export declare class SchemaMerger {
+    private readonly _editor;
     /**
-     * Gets the @see SchemaChanges between the two given Schemas from perspective of the source
-     * to the target schema. For example if source contains a class which does not exists in the
-     * target one, it would be listed as missing.
-     * @param targetSchema  The schema the differences gets merged into.
-     * @param sourceSchema  The schema to compare.
-     * @returns             An instance of @see SchemaChanges between the two schemas.
+     * Constructs a new instance of the SchemaMerger object.
+     * @param editingContext  The schema contexts that holds the schema to be edited.
      */
-    private getSchemaChanges;
+    constructor(editingContext: SchemaContext);
     /**
      * Copy the SchemaItems of the source schemas to the target schema.
      * @param targetSchema  The schema the SchemaItems gets merged to.
@@ -34,5 +33,18 @@ export declare class SchemaMerger {
      * @returns             The merged target schema.
      */
     merge(targetSchema: Schema, sourceSchema: Schema): Promise<Schema>;
+    /**
+     * Merges the schema differences into the target schema context.
+     * @param differences   The changes that shall be applied to the target schema.
+     * @alpha
+     */
+    merge(differences: SchemaDifferences): Promise<Schema>;
+    /**
+     * Merges the schema differences in the target schema. The target schema is defined
+     * in the given differences object.
+     * @param differences   The differences between a source schema and the target schema.
+     * @returns             The modified Schema.
+     */
+    private mergeSchemas;
 }
 //# sourceMappingURL=SchemaMerger.d.ts.map

package/lib/cjs/Merging/SchemaMerger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SchemaMerger.d.ts","sourceRoot":"","sources":["../../../src/Merging/SchemaMerger.ts"],"names":[],"mappings":"AAIA;;GAEG;AAEH,OAAO,EAAE,MAAM,EAAkB,MAAM,0BAA0B,CAAC;AAGlE,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAcxD;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,mBAAmB,CAAC;CACtC;AAED;;;;GAIG;AACH,qBAAa,YAAY;IACvB;;;;;;;OAOG;YACW,gBAAgB;IAW9B;;;;;OAKG;IACU,KAAK,CAAC,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CA0ChF"}
+{"version":3,"file":"SchemaMerger.d.ts","sourceRoot":"","sources":["../../../src/Merging/SchemaMerger.ts"],"names":[],"mappings":"AAIA;;GAEG;AAEH,OAAO,EAAE,MAAM,EAAE,KAAK,aAAa,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AACjF,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAExD,OAAO,EAAoB,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AAKvF;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,eAAe,EAAE,SAAS,CAAC;IACpC,QAAQ,CAAC,eAAe,EAAE,SAAS,CAAC;IACpC,QAAQ,CAAC,MAAM,EAAE,mBAAmB,CAAC;CACtC;AAED;;;;GAIG;AACH,qBAAa,YAAY;IAEvB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsB;IAE9C;;;OAGG;gBACS,cAAc,EAAE,aAAa;IAIzC;;;;;OAKG;IACI,KAAK,CAAC,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAEzE;;;;OAIG;IACI,KAAK,CAAC,WAAW,EAAE,iBAAiB,GAAG,OAAO,CAAC,MAAM,CAAC;IA0B7D;;;;;OAKG;YACW,YAAY;CA6C3B"}

package/lib/cjs/Merging/SchemaMerger.js

@@ -9,19 +9,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SchemaMerger = void 0;
 const ecschema_metadata_1 = require("@itwin/ecschema-metadata");
-const SchemaComparer_1 = require("../Validation/SchemaComparer");
 const Editor_1 = require("../Editing/Editor");
+const SchemaDifference_1 = require("../Differencing/SchemaDifference");
+const CustomAttributeMerger_1 = require("./CustomAttributeMerger");
 const SchemaItemMerger_1 = require("./SchemaItemMerger");
 const SchemaReferenceMerger_1 = require("./SchemaReferenceMerger");
-const CAClassMerger_1 = require("./CAClassMerger");
-const EnumerationMerger_1 = require("./EnumerationMerger");
-const ConstantMerger_1 = require("./ConstantMerger");
-const EntityClassMerger_1 = require("./EntityClassMerger");
-const StructClassMerger_1 = require("./StructClassMerger");
-const MixinMerger_1 = require("./MixinMerger");
-const CustomAttributeMerger_1 = require("./CustomAttributeMerger");
-const KindOfQuantityMerger_1 = require("./KindOfQuantityMerger");
-const RelationshipClassMerger_1 = require("./RelationshipClassMerger");
 /**
  * Class to merge two schemas together.
  * @see [[merge]] to merge the schemas.
@@ -29,94 +21,88 @@ const RelationshipClassMerger_1 = require("./RelationshipClassMerger");
  */
 class SchemaMerger {
     /**
-     * Gets the @see SchemaChanges between the two given Schemas from perspective of the source
-     * to the target schema. For example if source contains a class which does not exists in the
-     * target one, it would be listed as missing.
-     * @param targetSchema  The schema the differences gets merged into.
-     * @param sourceSchema  The schema to compare.
-     * @returns             An instance of @see SchemaChanges between the two schemas.
+     * Constructs a new instance of the SchemaMerger object.
+     * @param editingContext  The schema contexts that holds the schema to be edited.
      */
-    async getSchemaChanges(targetSchema, sourceSchema) {
-        const changesList = [];
-        const schemaComparer = new SchemaComparer_1.SchemaComparer({ report: changesList.push.bind(changesList) });
-        // It is important to compare the schema items by name, not full name as otherwise
-        // we'd often see differences when comparing two different schemas.
-        await schemaComparer.compareSchemas(sourceSchema, targetSchema);
-        return changesList[0];
+    constructor(editingContext) {
+        this._editor = new Editor_1.SchemaContextEditor(editingContext);
     }
     /**
-     * Copy the SchemaItems of the source schemas to the target schema.
-     * @param targetSchema  The schema the SchemaItems gets merged to.
-     * @param sourceSchema  The schema the SchemaItems gets copied from.
-     * @returns             The merged target schema.
+     * Merges the source and the target. If the target is a SchemaDifference, the
+     * source parameter must not be set. If it's a schema, it'll internally call
+     * the Differencing api and recall itself with the difference argument overload.
+     * @param input   The methods input either a schema or a SchemaDifferences
+     * @param source  A source schema.
+     * @returns       The merged schema.
+     * @alpha
      */
-    async merge(targetSchema, sourceSchema) {
-        const schemaChanges = await this.getSchemaChanges(targetSchema, sourceSchema);
-        const mergeContext = {
-            editor: new Editor_1.SchemaContextEditor(targetSchema.context),
-            targetSchema,
-            sourceSchema,
+    async merge(input, source) {
+        if (ecschema_metadata_1.Schema.isSchema(input)) {
+            if (source === undefined) {
+                throw new Error("When merging two schemas, source must not be undefined.");
+            }
+            return this.merge(await SchemaDifference_1.SchemaDifference.fromSchemas(input, source));
+        }
+        if (input.conflicts && input.conflicts.length > 0) {
+            throw new Error("Schema's can't be merged if there are unresolved conflicts.");
+        }
+        return this.mergeSchemas(input);
+    }
+    /**
+     * Merges the schema differences in the target schema. The target schema is defined
+     * in the given differences object.
+     * @param differences   The differences between a source schema and the target schema.
+     * @returns             The modified Schema.
+     */
+    async mergeSchemas(differences) {
+        const targetSchemaKey = ecschema_metadata_1.SchemaKey.parseString(differences.targetSchemaName);
+        const sourceSchemaKey = ecschema_metadata_1.SchemaKey.parseString(differences.sourceSchemaName);
+        const schema = await this._editor.getSchema(targetSchemaKey);
+        if (schema === undefined) {
+            throw new Error();
+        }
+        const context = {
+            editor: this._editor,
+            targetSchema: schema,
+            targetSchemaKey,
+            sourceSchemaKey,
         };
-        await (0, SchemaReferenceMerger_1.default)(mergeContext, schemaChanges);
-        const itemChanges = getSchemaItemChanges(schemaChanges);
-        await EnumerationMerger_1.default.mergeChanges(mergeContext, itemChanges.enumeratations);
-        await SchemaItemMerger_1.SchemaItemMerger.mergeChanges(mergeContext, itemChanges.propertyCategories);
-        await SchemaItemMerger_1.SchemaItemMerger.mergeChanges(mergeContext, itemChanges.unitSystems);
-        await SchemaItemMerger_1.SchemaItemMerger.mergeChanges(mergeContext, itemChanges.phenomenons);
-        await ConstantMerger_1.default.mergeChanges(mergeContext, itemChanges.constants);
-        await KindOfQuantityMerger_1.default.mergeChanges(mergeContext, itemChanges.kindOfQuantities);
-        // TODO: For now we just do simple copy and merging of properties and classes. For more complex types
-        //       with bases classes or relationships, this might need to get extended.
-        await CAClassMerger_1.default.mergeItemStubChanges(mergeContext, itemChanges.customAttributeClasses);
-        await StructClassMerger_1.default.mergeItemStubChanges(mergeContext, itemChanges.structClasses);
-        await EntityClassMerger_1.default.mergeItemStubChanges(mergeContext, itemChanges.entityClasses);
-        await MixinMerger_1.default.mergeItemStubChanges(mergeContext, itemChanges.mixins);
-        await RelationshipClassMerger_1.default.mergeItemStubChanges(mergeContext, itemChanges.relationships);
-        // 2nd pass to complete merge changes such as properties, baseClasses and mixins.
-        await CAClassMerger_1.default.mergeItemContentChanges(mergeContext, itemChanges.customAttributeClasses);
-        await StructClassMerger_1.default.mergeItemContentChanges(mergeContext, itemChanges.structClasses);
-        await EntityClassMerger_1.default.mergeItemContentChanges(mergeContext, itemChanges.entityClasses);
-        await MixinMerger_1.default.mergeItemContentChanges(mergeContext, itemChanges.mixins);
-        await RelationshipClassMerger_1.default.mergeItemContentChanges(mergeContext, itemChanges.relationships);
-        await (0, CustomAttributeMerger_1.mergeCustomAttributes)(mergeContext, schemaChanges.customAttributeChanges.values(), async (ca) => {
-            return mergeContext.editor.addCustomAttribute(mergeContext.targetSchema.schemaKey, ca);
-        });
-        // TODO: For now we directly manipulate the target schema. For error handing purposes, we should first
-        //       merge into a temporary schema and eventually swap that with the given instance.
-        return targetSchema;
+        if (differences.changes === undefined) {
+            return schema;
+        }
+        for (const referenceChange of differences.changes.filter(SchemaDifference_1.SchemaDifference.isSchemaReferenceDifference)) {
+            await (0, SchemaReferenceMerger_1.mergeSchemaReferences)(context, referenceChange);
+        }
+        const schemaDifference = differences.changes.find(SchemaDifference_1.SchemaDifference.isSchemaDifference);
+        if (schemaDifference !== undefined) {
+            await mergeSchemaProperties(schema, schemaDifference);
+        }
+        // Filter a list of possible schema item changes. This list gets filtered and order in the
+        // mergeSchemaItems method.
+        for await (const mergeResult of (0, SchemaItemMerger_1.mergeSchemaItems)(context, differences.changes)) {
+            if (mergeResult.errorMessage) {
+                throw new Error(mergeResult.errorMessage);
+            }
+        }
+        // At last the custom attributes gets merged because it could be that the CustomAttributes
+        // depend on classes that has to get merged in as items before.
+        for (const customAttributeChange of differences.changes.filter(SchemaDifference_1.SchemaDifference.isCustomAttributeDifference)) {
+            await (0, CustomAttributeMerger_1.mergeCustomAttribute)(context, customAttributeChange);
+        }
+        return schema;
     }
 }
 exports.SchemaMerger = SchemaMerger;
 /**
- * This helper method composes the different schema change objects to a single easier
- * to use object that should improve readability when the methods get called.
+ * Sets the editable properties of a Schema.
+ * @internal
  */
-function getSchemaItemChanges(schemaChanges) {
-    return {
-        get constants() { return filterChangesByItemType(schemaChanges.schemaItemChanges, ecschema_metadata_1.SchemaItemType.Constant); },
-        get customAttributeClasses() { return filterChangesByItemType(schemaChanges.classChanges, ecschema_metadata_1.SchemaItemType.CustomAttributeClass); },
-        get entityClasses() { return filterChangesByItemType(schemaChanges.classChanges, ecschema_metadata_1.SchemaItemType.EntityClass); },
-        get enumeratations() { return schemaChanges.enumerationChanges.values(); },
-        get kindOfQuantities() { return schemaChanges.kindOfQuantityChanges.values(); },
-        get mixins() { return filterChangesByItemType(schemaChanges.classChanges, ecschema_metadata_1.SchemaItemType.Mixin); },
-        get phenomenons() { return filterChangesByItemType(schemaChanges.schemaItemChanges, ecschema_metadata_1.SchemaItemType.Phenomenon); },
-        get propertyCategories() { return filterChangesByItemType(schemaChanges.schemaItemChanges, ecschema_metadata_1.SchemaItemType.PropertyCategory); },
-        get relationships() { return filterChangesByItemType(schemaChanges.classChanges, ecschema_metadata_1.SchemaItemType.RelationshipClass); },
-        get structClasses() { return filterChangesByItemType(schemaChanges.classChanges, ecschema_metadata_1.SchemaItemType.StructClass); },
-        get unitSystems() { return filterChangesByItemType(schemaChanges.schemaItemChanges, ecschema_metadata_1.SchemaItemType.UnitSystem); },
-    };
-}
-/**
- * Filters and returns the changed items by its schema item type.
- * @param changes   A map of changed schema items.
- * @param types     A list of schema item types to filter.
- * @returns         An Iterable with the filtered schema items.
- */
-function* filterChangesByItemType(changes, ...types) {
-    for (const change of changes.values()) {
-        if (types.includes(change.schemaItemType)) {
-            yield change;
-        }
+async function mergeSchemaProperties(schema, changes) {
+    if (changes.difference.label !== undefined) {
+        schema.setDisplayLabel(changes.difference.label);
+    }
+    if (changes.difference.description !== undefined) {
+        schema.setDescription(changes.difference.description);
     }
 }
 //# sourceMappingURL=SchemaMerger.js.map

package/lib/cjs/Merging/SchemaMerger.js.map

@@ -1 +1 @@
-{"version":3,"file":"SchemaMerger.js","sourceRoot":"","sources":["../../../src/Merging/SchemaMerger.ts"],"names":[],"mappings":"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","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n/** @packageDocumentation\r\n * @module Merging\r\n */\r\n\r\nimport { Schema, SchemaItemType } from \"@itwin/ecschema-metadata\";\r\nimport { SchemaChanges, SchemaItemChanges } from \"../Validation/SchemaChanges\";\r\nimport { SchemaComparer } from \"../Validation/SchemaComparer\";\r\nimport { SchemaContextEditor } from \"../Editing/Editor\";\r\nimport { SchemaItemMerger } from \"./SchemaItemMerger\";\r\n\r\nimport mergeSchemaReferences from \"./SchemaReferenceMerger\";\r\nimport CAClassMerger from \"./CAClassMerger\";\r\nimport EnumerationMerger from \"./EnumerationMerger\";\r\nimport ConstantsMerger from \"./ConstantMerger\";\r\nimport EntityClassMerger from \"./EntityClassMerger\";\r\nimport StructClassMerger from \"./StructClassMerger\";\r\nimport MixinMerger from \"./MixinMerger\";\r\nimport { mergeCustomAttributes } from \"./CustomAttributeMerger\";\r\nimport KindOfQuantityMerger from \"./KindOfQuantityMerger\";\r\nimport RelationshipClassMerger from \"./RelationshipClassMerger\";\r\n\r\n/**\r\n * Defines the context of a Schema merging run.\r\n * @beta\r\n */\r\nexport interface SchemaMergeContext {\r\n  readonly targetSchema: Schema;\r\n  readonly sourceSchema: Schema;\r\n  readonly editor: SchemaContextEditor;\r\n}\r\n\r\n/**\r\n * Class to merge two schemas together.\r\n * @see [[merge]] to merge the schemas.\r\n * @beta\r\n */\r\nexport class SchemaMerger {\r\n  /**\r\n   * Gets the @see SchemaChanges between the two given Schemas from perspective of the source\r\n   * to the target schema. For example if source contains a class which does not exists in the\r\n   * target one, it would be listed as missing.\r\n   * @param targetSchema  The schema the differences gets merged into.\r\n   * @param sourceSchema  The schema to compare.\r\n   * @returns             An instance of @see SchemaChanges between the two schemas.\r\n   */\r\n  private async getSchemaChanges(targetSchema: Schema, sourceSchema: Schema): Promise<SchemaChanges> {\r\n    const changesList: SchemaChanges[] = [];\r\n    const schemaComparer = new SchemaComparer({ report: changesList.push.bind(changesList) });\r\n\r\n    // It is important to compare the schema items by name, not full name as otherwise\r\n    // we'd often see differences when comparing two different schemas.\r\n    await schemaComparer.compareSchemas(sourceSchema, targetSchema);\r\n\r\n    return changesList[0];\r\n  }\r\n\r\n  /**\r\n   * Copy the SchemaItems of the source schemas to the target schema.\r\n   * @param targetSchema  The schema the SchemaItems gets merged to.\r\n   * @param sourceSchema  The schema the SchemaItems gets copied from.\r\n   * @returns             The merged target schema.\r\n   */\r\n  public async merge(targetSchema: Schema, sourceSchema: Schema): Promise<Schema> {\r\n    const schemaChanges = await this.getSchemaChanges(targetSchema, sourceSchema);\r\n    const mergeContext: SchemaMergeContext = {\r\n      editor: new SchemaContextEditor(targetSchema.context),\r\n      targetSchema,\r\n      sourceSchema,\r\n    };\r\n\r\n    await mergeSchemaReferences(mergeContext, schemaChanges);\r\n\r\n    const itemChanges = getSchemaItemChanges(schemaChanges);\r\n    await EnumerationMerger.mergeChanges(mergeContext, itemChanges.enumeratations);\r\n    await SchemaItemMerger.mergeChanges(mergeContext, itemChanges.propertyCategories);\r\n\r\n    await SchemaItemMerger.mergeChanges(mergeContext, itemChanges.unitSystems);\r\n    await SchemaItemMerger.mergeChanges(mergeContext, itemChanges.phenomenons);\r\n    await ConstantsMerger.mergeChanges(mergeContext, itemChanges.constants);\r\n    await KindOfQuantityMerger.mergeChanges(mergeContext, itemChanges.kindOfQuantities);\r\n\r\n    // TODO: For now we just do simple copy and merging of properties and classes. For more complex types\r\n    //       with bases classes or relationships, this might need to get extended.\r\n    await CAClassMerger.mergeItemStubChanges(mergeContext, itemChanges.customAttributeClasses);\r\n    await StructClassMerger.mergeItemStubChanges(mergeContext, itemChanges.structClasses);\r\n    await EntityClassMerger.mergeItemStubChanges(mergeContext, itemChanges.entityClasses);\r\n    await MixinMerger.mergeItemStubChanges(mergeContext, itemChanges.mixins);\r\n    await RelationshipClassMerger.mergeItemStubChanges(mergeContext, itemChanges.relationships);\r\n\r\n    // 2nd pass to complete merge changes such as properties, baseClasses and mixins.\r\n    await CAClassMerger.mergeItemContentChanges(mergeContext, itemChanges.customAttributeClasses);\r\n    await StructClassMerger.mergeItemContentChanges(mergeContext, itemChanges.structClasses);\r\n    await EntityClassMerger.mergeItemContentChanges(mergeContext, itemChanges.entityClasses);\r\n    await MixinMerger.mergeItemContentChanges(mergeContext, itemChanges.mixins);\r\n    await RelationshipClassMerger.mergeItemContentChanges(mergeContext, itemChanges.relationships);\r\n\r\n    await mergeCustomAttributes(mergeContext, schemaChanges.customAttributeChanges.values(), async (ca) => {\r\n      return mergeContext.editor.addCustomAttribute(mergeContext.targetSchema.schemaKey, ca);\r\n    });\r\n\r\n    // TODO: For now we directly manipulate the target schema. For error handing purposes, we should first\r\n    //       merge into a temporary schema and eventually swap that with the given instance.\r\n    return targetSchema;\r\n  }\r\n}\r\n\r\n/**\r\n * This helper method composes the different schema change objects to a single easier\r\n * to use object that should improve readability when the methods get called.\r\n */\r\nfunction getSchemaItemChanges(schemaChanges: SchemaChanges) {\r\n  return {\r\n    get constants() { return filterChangesByItemType(schemaChanges.schemaItemChanges, SchemaItemType.Constant); },\r\n    get customAttributeClasses() { return filterChangesByItemType(schemaChanges.classChanges, SchemaItemType.CustomAttributeClass); },\r\n    get entityClasses() { return filterChangesByItemType(schemaChanges.classChanges, SchemaItemType.EntityClass); },\r\n    get enumeratations() { return schemaChanges.enumerationChanges.values(); },\r\n    get kindOfQuantities() { return schemaChanges.kindOfQuantityChanges.values(); },\r\n    get mixins() { return filterChangesByItemType(schemaChanges.classChanges, SchemaItemType.Mixin); },\r\n    get phenomenons() { return filterChangesByItemType(schemaChanges.schemaItemChanges, SchemaItemType.Phenomenon); },\r\n    get propertyCategories() { return filterChangesByItemType(schemaChanges.schemaItemChanges, SchemaItemType.PropertyCategory); },\r\n    get relationships() { return filterChangesByItemType(schemaChanges.classChanges, SchemaItemType.RelationshipClass); },\r\n    get structClasses() { return filterChangesByItemType(schemaChanges.classChanges, SchemaItemType.StructClass); },\r\n    get unitSystems() { return filterChangesByItemType(schemaChanges.schemaItemChanges, SchemaItemType.UnitSystem); },\r\n  };\r\n}\r\n\r\n/**\r\n * Filters and returns the changed items by its schema item type.\r\n * @param changes   A map of changed schema items.\r\n * @param types     A list of schema item types to filter.\r\n * @returns         An Iterable with the filtered schema items.\r\n */\r\nfunction * filterChangesByItemType<TChange extends SchemaItemChanges>(changes: Map<string, TChange>, ...types: SchemaItemType[]): Iterable<TChange> {\r\n  for(const change of changes.values()) {\r\n    if (types.includes(change.schemaItemType)) {\r\n      yield change;\r\n    }\r\n  }\r\n}\r\n"]}
+{"version":3,"file":"SchemaMerger.js","sourceRoot":"","sources":["../../../src/Merging/SchemaMerger.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG;;;AAEH,gEAAiF;AACjF,8CAAwD;AAExD,uEAAuF;AACvF,mEAA+D;AAC/D,yDAAsD;AACtD,mEAAgE;AAahE;;;;GAIG;AACH,MAAa,YAAY;IAIvB;;;OAGG;IACH,YAAY,cAA6B;QACvC,IAAI,CAAC,OAAO,GAAG,IAAI,4BAAmB,CAAC,cAAc,CAAC,CAAC;IACzD,CAAC;IAiBD;;;;;;;;OAQG;IACI,KAAK,CAAC,KAAK,CAAC,KAAiC,EAAE,MAAe;QACnE,IAAG,0BAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE;YACzB,IAAG,MAAM,KAAK,SAAS,EAAE;gBACvB,MAAM,IAAI,KAAK,CAAC,yDAAyD,CAAC,CAAC;aAC5E;YACD,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,mCAAgB,CAAC,WAAW,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC;SACtE;QAED,IAAG,KAAK,CAAC,SAAS,IAAI,KAAK,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE;YAChD,MAAM,IAAI,KAAK,CAAC,6DAA6D,CAAC,CAAC;SAChF;QAED,OAAO,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;IAClC,CAAC;IAED;;;;;OAKG;IACK,KAAK,CAAC,YAAY,CAAC,WAA8B;QACvD,MAAM,eAAe,GAAG,6BAAS,CAAC,WAAW,CAAC,WAAW,CAAC,gBAAgB,CAAC,CAAC;QAC5E,MAAM,eAAe,GAAG,6BAAS,CAAC,WAAW,CAAC,WAAW,CAAC,gBAAgB,CAAC,CAAC;QAE5E,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,eAAe,CAAC,CAAC;QAC7D,IAAI,MAAM,KAAK,SAAS,EAAE;YACxB,MAAM,IAAI,KAAK,EAAE,CAAC;SACnB;QAED,MAAM,OAAO,GAAuB;YAClC,MAAM,EAAE,IAAI,CAAC,OAAO;YACpB,YAAY,EAAE,MAAM;YACpB,eAAe;YACf,eAAe;SAChB,CAAC;QAEF,IAAG,WAAW,CAAC,OAAO,KAAK,SAAS,EAAE;YACpC,OAAO,MAAM,CAAC;SACf;QAED,KAAK,MAAM,eAAe,IAAI,WAAW,CAAC,OAAO,CAAC,MAAM,CAAC,mCAAgB,CAAC,2BAA2B,CAAC,EAAE;YACtG,MAAM,IAAA,6CAAqB,EAAC,OAAO,EAAE,eAAe,CAAC,CAAC;SACvD;QAED,MAAM,gBAAgB,GAAG,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,mCAAgB,CAAC,kBAAkB,CAAC,CAAC;QACvF,IAAG,gBAAgB,KAAK,SAAS,EAAE;YACjC,MAAM,qBAAqB,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;SACvD;QAED,0FAA0F;QAC1F,2BAA2B;QAC3B,IAAI,KAAK,EAAE,MAAM,WAAW,IAAI,IAAA,mCAAgB,EAAC,OAAO,EAAE,WAAW,CAAC,OAAO,CAAC,EAAE;YAC9E,IAAG,WAAW,CAAC,YAAY,EAAE;gBAC3B,MAAM,IAAI,KAAK,CAAC,WAAW,CAAC,YAAY,CAAC,CAAC;aAC3C;SACF;QAED,0FAA0F;QAC1F,+DAA+D;QAC/D,KAAK,MAAM,qBAAqB,IAAI,WAAW,CAAC,OAAO,CAAC,MAAM,CAAC,mCAAgB,CAAC,2BAA2B,CAAC,EAAE;YAC5G,MAAM,IAAA,4CAAoB,EAAC,OAAO,EAAE,qBAAqB,CAAC,CAAC;SAC5D;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;CACF;AAtGD,oCAsGC;AAED;;;GAGG;AACH,KAAK,UAAU,qBAAqB,CAAC,MAAqB,EAAE,OAAyB;IACnF,IAAG,OAAO,CAAC,UAAU,CAAC,KAAK,KAAK,SAAS,EAAE;QACzC,MAAM,CAAC,eAAe,CAAC,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;KAClD;IACD,IAAG,OAAO,CAAC,UAAU,CAAC,WAAW,KAAK,SAAS,EAAE;QAC/C,MAAM,CAAC,cAAc,CAAC,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;KACvD;AACH,CAAC","sourcesContent":["/*---------------------------------------------------------------------------------------------\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\n* See LICENSE.md in the project root for license terms and full copyright notice.\n*--------------------------------------------------------------------------------------------*/\n/** @packageDocumentation\n * @module Merging\n */\n\nimport { Schema, type SchemaContext, SchemaKey } from \"@itwin/ecschema-metadata\";\nimport { SchemaContextEditor } from \"../Editing/Editor\";\nimport { MutableSchema } from \"../Editing/Mutable/MutableSchema\";\nimport { SchemaDifference, SchemaDifferences } from \"../Differencing/SchemaDifference\";\nimport { mergeCustomAttribute } from \"./CustomAttributeMerger\";\nimport { mergeSchemaItems } from \"./SchemaItemMerger\";\nimport { mergeSchemaReferences } from \"./SchemaReferenceMerger\";\n\n/**\n * Defines the context of a Schema merging run.\n * @beta\n */\nexport interface SchemaMergeContext {\n  readonly targetSchema: Schema;\n  readonly targetSchemaKey: SchemaKey;\n  readonly sourceSchemaKey: SchemaKey;\n  readonly editor: SchemaContextEditor;\n}\n\n/**\n * Class to merge two schemas together.\n * @see [[merge]] to merge the schemas.\n * @beta\n */\nexport class SchemaMerger {\n\n  private readonly _editor: SchemaContextEditor;\n\n  /**\n   * Constructs a new instance of the SchemaMerger object.\n   * @param editingContext  The schema contexts that holds the schema to be edited.\n   */\n  constructor(editingContext: SchemaContext) {\n    this._editor = new SchemaContextEditor(editingContext);\n  }\n\n  /**\n   * Copy the SchemaItems of the source schemas to the target schema.\n   * @param targetSchema  The schema the SchemaItems gets merged to.\n   * @param sourceSchema  The schema the SchemaItems gets copied from.\n   * @returns             The merged target schema.\n   */\n  public merge(targetSchema: Schema, sourceSchema: Schema): Promise<Schema>;\n\n  /**\n   * Merges the schema differences into the target schema context.\n   * @param differences   The changes that shall be applied to the target schema.\n   * @alpha\n   */\n  public merge(differences: SchemaDifferences): Promise<Schema>;\n\n  /**\n   * Merges the source and the target. If the target is a SchemaDifference, the\n   * source parameter must not be set. If it's a schema, it'll internally call\n   * the Differencing api and recall itself with the difference argument overload.\n   * @param input   The methods input either a schema or a SchemaDifferences\n   * @param source  A source schema.\n   * @returns       The merged schema.\n   * @alpha\n   */\n  public async merge(input: SchemaDifferences | Schema, source?: Schema): Promise<Schema> {\n    if(Schema.isSchema(input)) {\n      if(source === undefined) {\n        throw new Error(\"When merging two schemas, source must not be undefined.\");\n      }\n      return this.merge(await SchemaDifference.fromSchemas(input, source));\n    }\n\n    if(input.conflicts && input.conflicts.length > 0) {\n      throw new Error(\"Schema's can't be merged if there are unresolved conflicts.\");\n    }\n\n    return this.mergeSchemas(input);\n  }\n\n  /**\n   * Merges the schema differences in the target schema. The target schema is defined\n   * in the given differences object.\n   * @param differences   The differences between a source schema and the target schema.\n   * @returns             The modified Schema.\n   */\n  private async mergeSchemas(differences: SchemaDifferences): Promise<Schema> {\n    const targetSchemaKey = SchemaKey.parseString(differences.targetSchemaName);\n    const sourceSchemaKey = SchemaKey.parseString(differences.sourceSchemaName);\n\n    const schema = await this._editor.getSchema(targetSchemaKey);\n    if (schema === undefined) {\n      throw new Error();\n    }\n\n    const context: SchemaMergeContext = {\n      editor: this._editor,\n      targetSchema: schema,\n      targetSchemaKey,\n      sourceSchemaKey,\n    };\n\n    if(differences.changes === undefined) {\n      return schema;\n    }\n\n    for (const referenceChange of differences.changes.filter(SchemaDifference.isSchemaReferenceDifference)) {\n      await mergeSchemaReferences(context, referenceChange);\n    }\n\n    const schemaDifference = differences.changes.find(SchemaDifference.isSchemaDifference);\n    if(schemaDifference !== undefined) {\n      await mergeSchemaProperties(schema, schemaDifference);\n    }\n\n    // Filter a list of possible schema item changes. This list gets filtered and order in the\n    // mergeSchemaItems method.\n    for await (const mergeResult of mergeSchemaItems(context, differences.changes)) {\n      if(mergeResult.errorMessage) {\n        throw new Error(mergeResult.errorMessage);\n      }\n    }\n\n    // At last the custom attributes gets merged because it could be that the CustomAttributes\n    // depend on classes that has to get merged in as items before.\n    for (const customAttributeChange of differences.changes.filter(SchemaDifference.isCustomAttributeDifference)) {\n      await mergeCustomAttribute(context, customAttributeChange);\n    }\n\n    return schema;\n  }\n}\n\n/**\n * Sets the editable properties of a Schema.\n * @internal\n */\nasync function mergeSchemaProperties(schema: MutableSchema, changes: SchemaDifference) {\n  if(changes.difference.label !== undefined) {\n    schema.setDisplayLabel(changes.difference.label);\n  }\n  if(changes.difference.description !== undefined) {\n    schema.setDescription(changes.difference.description);\n  }\n}\n"]}

package/lib/cjs/Merging/SchemaReferenceMerger.d.ts

@@ -1,10 +1,10 @@
-import { SchemaChanges } from "../Validation/SchemaChanges";
-import { SchemaMergeContext } from "./SchemaMerger";
+import { type SchemaMergeContext } from "./SchemaMerger";
+import { type SchemaReferenceDifference } from "../Differencing/SchemaDifference";
 /**
  * Merges the schema references of two schemas.
- * @param mergeContext  current merge context
- * @param changes       schema changes.
+ * @param context  current merge context
+ * @param change       schema changes.
  * @internal
  */
-export default function mergeSchemaReferences(mergeContext: SchemaMergeContext, changes: SchemaChanges): Promise<void>;
+export declare function mergeSchemaReferences(context: SchemaMergeContext, change: SchemaReferenceDifference): Promise<void>;
 //# sourceMappingURL=SchemaReferenceMerger.d.ts.map

package/lib/cjs/Merging/SchemaReferenceMerger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SchemaReferenceMerger.d.ts","sourceRoot":"","sources":["../../../src/Merging/SchemaReferenceMerger.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAEpD;;;;;GAKG;AACH,wBAA8B,qBAAqB,CAAC,YAAY,EAAE,kBAAkB,EAAE,OAAO,EAAE,aAAa,iBA+B3G"}
+{"version":3,"file":"SchemaReferenceMerger.d.ts","sourceRoot":"","sources":["../../../src/Merging/SchemaReferenceMerger.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACzD,OAAO,EAAE,KAAK,yBAAyB,EAAE,MAAM,kCAAkC,CAAC;AAGlF;;;;;GAKG;AACH,wBAAsB,qBAAqB,CAAC,OAAO,EAAE,kBAAkB,EAAE,MAAM,EAAE,yBAAyB,iBA8BzG"}