@itwin/ecschema-metadata 4.8.0-dev.9 → 4.9.0-dev.1

package/lib/esm/Deserialization/Helper.js

@@ -0,0 +1,871 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+import { SchemaContext } from "../Context";
+import { parsePrimitiveType, parseSchemaItemType, SchemaItemType, SchemaMatchType } from "../ECObjects";
+import { ECObjectsError, ECObjectsStatus } from "../Exception";
+import { SchemaItem } from "../Metadata/SchemaItem";
+import { ECVersion, SchemaItemKey, SchemaKey } from "../SchemaKey";
+import { SchemaPartVisitorDelegate } from "../SchemaPartVisitorDelegate";
+import { getItemNamesFromFormatString } from "@itwin/core-quantity";
+import { SchemaGraph } from "../utils/SchemaGraph";
+/**
+ * This class properly handles the order the deserialization of ECSchemas and SchemaItems from serialized formats.
+ * For example, when deserializing an ECClass most times all base class should be de-serialized before the given class.
+ * @internal
+ */
+export class SchemaReadHelper {
+    constructor(parserType, context, visitor) {
+        this._context = (undefined !== context) ? context : new SchemaContext();
+        this._visitorHelper = visitor ? new SchemaPartVisitorDelegate(visitor) : undefined;
+        this._parserType = parserType;
+    }
+    /**
+     * Creates a complete SchemaInfo and starts parsing the schema from a serialized representation.
+     * The info and schema promise will be registered with the SchemaContext.  The complete schema can be retrieved by
+     * calling getCachedSchema on the context.
+     * @param schema The Schema to populate
+     * @param rawSchema The serialized data to use to populate the Schema.
+     */
+    async readSchemaInfo(schema, rawSchema) {
+        // Ensure context matches schema context
+        if (schema.context) {
+            if (this._context !== schema.context)
+                throw new ECObjectsError(ECObjectsStatus.DifferentSchemaContexts, "The SchemaContext of the schema must be the same SchemaContext held by the SchemaReadHelper.");
+        }
+        else {
+            schema.setContext(this._context);
+        }
+        this._parser = new this._parserType(rawSchema);
+        // Loads all of the properties on the Schema object
+        await schema.fromJSON(this._parser.parseSchema());
+        this._schema = schema;
+        const schemaInfo = { schemaKey: schema.schemaKey, references: [] };
+        for (const reference of this._parser.getReferences()) {
+            const refKey = new SchemaKey(reference.name, ECVersion.fromString(reference.version));
+            schemaInfo.references.push({ schemaKey: refKey });
+        }
+        this._schemaInfo = schemaInfo;
+        // Need to add this schema to the context to be able to locate schemaItems within the context.
+        if (!this._context.schemaExists(schema.schemaKey)) {
+            await this._context.addSchemaPromise(schemaInfo, schema, this.loadSchema(schemaInfo, schema));
+        }
+        return schemaInfo;
+    }
+    /**
+     * Populates the given Schema from a serialized representation.
+     * @param schema The Schema to populate
+     * @param rawSchema The serialized data to use to populate the Schema.
+     */
+    async readSchema(schema, rawSchema) {
+        if (!this._schemaInfo) {
+            await this.readSchemaInfo(schema, rawSchema);
+        }
+        const cachedSchema = await this._context.getCachedSchema(this._schemaInfo.schemaKey, SchemaMatchType.Latest);
+        if (undefined === cachedSchema)
+            throw new ECObjectsError(ECObjectsStatus.UnableToLoadSchema, `Could not load schema ${schema.schemaKey.toString()}`);
+        return cachedSchema;
+    }
+    /* Finish loading the rest of the schema */
+    async loadSchema(schemaInfo, schema) {
+        // Verify that there are no schema reference cycles, this will start schema loading by loading their headers
+        (await SchemaGraph.generateGraph(schemaInfo, this._context)).throwIfCycles();
+        for (const reference of schemaInfo.references) {
+            await this.loadSchemaReference(schemaInfo, reference.schemaKey);
+        }
+        if (this._visitorHelper)
+            await this._visitorHelper.visitSchema(schema, false);
+        // Load all schema items
+        for (const [itemName, itemType, rawItem] of this._parser.getItems()) {
+            // Make sure the item has not already been read. No need to check the SchemaContext because all SchemaItems are added to a Schema,
+            // which would be found when adding to the context.
+            if (await schema.getItem(itemName) !== undefined)
+                continue;
+            const loadedItem = await this.loadSchemaItem(schema, itemName, itemType, rawItem);
+            if (loadedItem && this._visitorHelper) {
+                await this._visitorHelper.visitSchemaPart(loadedItem);
+            }
+        }
+        await this.loadCustomAttributes(schema, this._parser.getSchemaCustomAttributeProviders());
+        if (this._visitorHelper)
+            await this._visitorHelper.visitSchema(schema);
+        return schema;
+    }
+    /**
+     * Populates the given Schema from a serialized representation.
+     * @param schema The Schema to populate
+     * @param rawSchema The serialized data to use to populate the Schema.
+     */
+    readSchemaSync(schema, rawSchema) {
+        this._parser = new this._parserType(rawSchema);
+        // Loads all of the properties on the Schema object
+        schema.fromJSONSync(this._parser.parseSchema());
+        this._schema = schema;
+        // Need to add this schema to the context to be able to locate schemaItems within the context.
+        if (!this._context.schemaExists(schema.schemaKey))
+            this._context.addSchemaSync(schema);
+        // Load schema references first
+        // Need to figure out if other schemas are present.
+        for (const reference of this._parser.getReferences()) {
+            this.loadSchemaReferenceSync(reference);
+        }
+        if (this._visitorHelper)
+            this._visitorHelper.visitSchemaSync(schema, false);
+        // Load all schema items
+        for (const [itemName, itemType, rawItem] of this._parser.getItems()) {
+            // Make sure the item has not already been read. No need to check the SchemaContext because all SchemaItems are added to a Schema,
+            // which would be found when adding to the context.
+            if (schema.getItemSync(itemName) !== undefined)
+                continue;
+            const loadedItem = this.loadSchemaItemSync(schema, itemName, itemType, rawItem);
+            if (loadedItem && this._visitorHelper) {
+                this._visitorHelper.visitSchemaPartSync(loadedItem);
+            }
+        }
+        this.loadCustomAttributesSync(schema, this._parser.getSchemaCustomAttributeProviders());
+        if (this._visitorHelper)
+            this._visitorHelper.visitSchemaSync(schema);
+        return schema;
+    }
+    /**
+     * Ensures that the schema references can be located and adds them to the schema.
+     * @param ref The object to read the SchemaReference's props from.
+     */
+    async loadSchemaReference(schemaInfo, refKey) {
+        const refSchema = await this._context.getSchema(refKey, SchemaMatchType.LatestWriteCompatible);
+        if (undefined === refSchema)
+            throw new ECObjectsError(ECObjectsStatus.UnableToLocateSchema, `Could not locate the referenced schema, ${refKey.name}.${refKey.version.toString()}, of ${schemaInfo.schemaKey.name}`);
+        await this._schema.addReference(refSchema);
+        const results = this.validateSchemaReferences(this._schema);
+        let errorMessage = "";
+        for (const result of results) {
+            errorMessage += `${result}\r\n`;
+        }
+        if (errorMessage) {
+            throw new ECObjectsError(ECObjectsStatus.InvalidECJson, `${errorMessage}`);
+        }
+    }
+    /**
+     * Ensures that the schema references can be located and adds them to the schema.
+     * @param ref The object to read the SchemaReference's props from.
+     */
+    loadSchemaReferenceSync(ref) {
+        const schemaKey = new SchemaKey(ref.name, ECVersion.fromString(ref.version));
+        const refSchema = this._context.getSchemaSync(schemaKey, SchemaMatchType.LatestWriteCompatible);
+        if (!refSchema)
+            throw new ECObjectsError(ECObjectsStatus.UnableToLocateSchema, `Could not locate the referenced schema, ${ref.name}.${ref.version}, of ${this._schema.schemaKey.name}`);
+        this._schema.addReferenceSync(refSchema);
+        SchemaGraph.generateGraphSync(this._schema).throwIfCycles();
+        const results = this.validateSchemaReferences(this._schema);
+        let errorMessage = "";
+        for (const result of results) {
+            errorMessage += `${result}\r\n`;
+        }
+        if (errorMessage) {
+            throw new ECObjectsError(ECObjectsStatus.InvalidECJson, `${errorMessage}`);
+        }
+    }
+    /**
+     * Validates schema references against multiple EC rules.
+     * @param schema The schema to validate.
+     */
+    *validateSchemaReferences(schema) {
+        const aliases = new Map();
+        for (const schemaRef of schema.references) {
+            if (schemaRef.customAttributes && schemaRef.customAttributes.has("CoreCustomAttributes.SupplementalSchema"))
+                yield `Referenced schema '${schemaRef.name}' of schema '${schema.name}' is a supplemental schema. Supplemental schemas are not allowed to be referenced.`;
+            if (schema.schemaKey.matches(schemaRef.schemaKey))
+                yield `Schema '${schema.name}' has reference cycles: '${schema.name} --> ${schemaRef.name}'`;
+            if (aliases.has(schemaRef.alias)) {
+                const currentRef = aliases.get(schemaRef.alias);
+                yield `Schema '${schema.name}' has multiple schema references (${currentRef.name}, $schemaRef.name}) with the same alias '${schemaRef.alias}', which is not allowed.`;
+            }
+            else {
+                aliases.set(schemaRef.alias, schemaRef);
+            }
+        }
+    }
+    /**
+     * Given the schema item object, the anticipated type and the name a schema item is created and loaded into the schema provided.
+     * @param schema The Schema the SchemaItem to.
+     * @param name The name of the schema item to be loaded.
+     * @param itemType The SchemaItemType of the item to load.
+     * @param schemaItemObject The Object to populate the SchemaItem with.
+     */
+    async loadSchemaItem(schema, name, itemType, schemaItemObject) {
+        let schemaItem;
+        switch (parseSchemaItemType(itemType)) {
+            case SchemaItemType.EntityClass:
+                schemaItem = await schema.createEntityClass(name);
+                await this.loadEntityClass(schemaItem, schemaItemObject);
+                break;
+            case SchemaItemType.StructClass:
+                schemaItem = await schema.createStructClass(name);
+                const structProps = this._parser.parseStructClass(schemaItemObject);
+                await this.loadClass(schemaItem, structProps, schemaItemObject);
+                break;
+            case SchemaItemType.Mixin:
+                schemaItem = await schema.createMixinClass(name);
+                await this.loadMixin(schemaItem, schemaItemObject);
+                break;
+            case SchemaItemType.CustomAttributeClass:
+                schemaItem = await schema.createCustomAttributeClass(name);
+                const caClassProps = this._parser.parseCustomAttributeClass(schemaItemObject);
+                await this.loadClass(schemaItem, caClassProps, schemaItemObject);
+                break;
+            case SchemaItemType.RelationshipClass:
+                schemaItem = await schema.createRelationshipClass(name);
+                await this.loadRelationshipClass(schemaItem, schemaItemObject);
+                break;
+            case SchemaItemType.KindOfQuantity:
+                schemaItem = await schema.createKindOfQuantity(name);
+                await this.loadKindOfQuantity(schemaItem, schemaItemObject);
+                break;
+            case SchemaItemType.Unit:
+                schemaItem = await schema.createUnit(name);
+                await this.loadUnit(schemaItem, schemaItemObject);
+                break;
+            case SchemaItemType.Constant:
+                schemaItem = await schema.createConstant(name);
+                await this.loadConstant(schemaItem, schemaItemObject);
+                break;
+            case SchemaItemType.InvertedUnit:
+                schemaItem = await schema.createInvertedUnit(name);
+                await this.loadInvertedUnit(schemaItem, schemaItemObject);
+                break;
+            case SchemaItemType.Format:
+                schemaItem = await schema.createFormat(name);
+                await this.loadFormat(schemaItem, schemaItemObject);
+                break;
+            case SchemaItemType.Phenomenon:
+                schemaItem = await schema.createPhenomenon(name);
+                const phenomenonProps = this._parser.parsePhenomenon(schemaItemObject);
+                await schemaItem.fromJSON(phenomenonProps);
+                break;
+            case SchemaItemType.UnitSystem:
+                schemaItem = await schema.createUnitSystem(name);
+                await schemaItem.fromJSON(this._parser.parseUnitSystem(schemaItemObject));
+                break;
+            case SchemaItemType.PropertyCategory:
+                schemaItem = await schema.createPropertyCategory(name);
+                const propertyCategoryProps = this._parser.parsePropertyCategory(schemaItemObject);
+                await schemaItem.fromJSON(propertyCategoryProps);
+                break;
+            case SchemaItemType.Enumeration:
+                schemaItem = await schema.createEnumeration(name);
+                const enumerationProps = this._parser.parseEnumeration(schemaItemObject);
+                await schemaItem.fromJSON(enumerationProps);
+                break;
+            // NOTE: we are being permissive here and allowing unknown types to silently fail. Not sure if we want to hard fail or just do a basic deserialization
+        }
+        return schemaItem;
+    }
+    /**
+     * Given the schema item object, the anticipated type and the name a schema item is created and loaded into the schema provided.
+     * @param schema The Schema the SchemaItem to.
+     * @param name The name of the schema item to be loaded.
+     * @param itemType The SchemaItemType of the item to load.
+     * @param schemaItemObject The Object to populate the SchemaItem with.
+     */
+    loadSchemaItemSync(schema, name, itemType, schemaItemObject) {
+        let schemaItem;
+        switch (parseSchemaItemType(itemType)) {
+            case SchemaItemType.EntityClass:
+                schemaItem = schema.createEntityClassSync(name);
+                this.loadEntityClassSync(schemaItem, schemaItemObject);
+                break;
+            case SchemaItemType.StructClass:
+                schemaItem = schema.createStructClassSync(name);
+                const structProps = this._parser.parseStructClass(schemaItemObject);
+                this.loadClassSync(schemaItem, structProps, schemaItemObject);
+                break;
+            case SchemaItemType.Mixin:
+                schemaItem = schema.createMixinClassSync(name);
+                this.loadMixinSync(schemaItem, schemaItemObject);
+                break;
+            case SchemaItemType.CustomAttributeClass:
+                schemaItem = schema.createCustomAttributeClassSync(name);
+                const caClassProps = this._parser.parseCustomAttributeClass(schemaItemObject);
+                this.loadClassSync(schemaItem, caClassProps, schemaItemObject);
+                break;
+            case SchemaItemType.RelationshipClass:
+                schemaItem = schema.createRelationshipClassSync(name);
+                this.loadRelationshipClassSync(schemaItem, schemaItemObject);
+                break;
+            case SchemaItemType.KindOfQuantity:
+                schemaItem = schema.createKindOfQuantitySync(name);
+                this.loadKindOfQuantitySync(schemaItem, schemaItemObject);
+                break;
+            case SchemaItemType.Unit:
+                schemaItem = schema.createUnitSync(name);
+                this.loadUnitSync(schemaItem, schemaItemObject);
+                break;
+            case SchemaItemType.Constant:
+                schemaItem = schema.createConstantSync(name);
+                this.loadConstantSync(schemaItem, schemaItemObject);
+                break;
+            case SchemaItemType.InvertedUnit:
+                schemaItem = schema.createInvertedUnitSync(name);
+                this.loadInvertedUnitSync(schemaItem, schemaItemObject);
+                break;
+            case SchemaItemType.Format:
+                schemaItem = schema.createFormatSync(name);
+                this.loadFormatSync(schemaItem, schemaItemObject);
+                break;
+            case SchemaItemType.Phenomenon:
+                schemaItem = schema.createPhenomenonSync(name);
+                const phenomenonProps = this._parser.parsePhenomenon(schemaItemObject);
+                schemaItem.fromJSONSync(phenomenonProps);
+                break;
+            case SchemaItemType.UnitSystem:
+                schemaItem = schema.createUnitSystemSync(name);
+                schemaItem.fromJSONSync(this._parser.parseUnitSystem(schemaItemObject));
+                break;
+            case SchemaItemType.PropertyCategory:
+                schemaItem = schema.createPropertyCategorySync(name);
+                const propertyCategoryProps = this._parser.parsePropertyCategory(schemaItemObject);
+                schemaItem.fromJSONSync(propertyCategoryProps);
+                break;
+            case SchemaItemType.Enumeration:
+                schemaItem = schema.createEnumerationSync(name);
+                const enumerationProps = this._parser.parseEnumeration(schemaItemObject);
+                schemaItem.fromJSONSync(enumerationProps);
+                break;
+            // NOTE: we are being permissive here and allowing unknown types to silently fail. Not sure if we want to hard fail or just do a basic deserialization
+        }
+        return schemaItem;
+    }
+    /**
+     * Given the full (Schema.ItemName) or qualified (alias:ItemName) item name, returns
+     * a tuple of strings in the format ["SchemaName", "ItemName"]. The schema name may be
+     * empty if the item comes from the schema being parsed.
+     * @param fullOrQualifiedName The full or qualified name of the schema item.
+     * @param schema The schema that will be used to lookup the schema name by alias, if necessary.
+     */
+    static resolveSchemaAndItemName(fullOrQualifiedName, schema) {
+        const [schemaName, itemName] = SchemaItem.parseFullName(fullOrQualifiedName);
+        // If a schema is provided we attempt to resolve the alias by looking at the reference schemas.
+        if (undefined !== schema && -1 !== fullOrQualifiedName.indexOf(":")) {
+            const refName = schema.getReferenceNameByAlias(schemaName);
+            if (undefined === refName)
+                throw new ECObjectsError(ECObjectsStatus.UnableToLocateSchema, `Could not resolve schema alias '${schemaName}' for schema item '${itemName}.`);
+            return [refName, itemName];
+        }
+        return [schemaName, itemName];
+    }
+    /**
+     * Finds the a SchemaItem matching the name first by checking the schema that is being deserialized. If it does
+     * not exist within the schema, the SchemaContext will be searched.
+     * @param name The full (Schema.ItemName) or qualified (alias:ItemName) name of the SchemaItem to search for.
+     * @param skipVisitor Used to break Mixin -appliesTo-> Entity -extends-> Mixin cycle.
+     * @param loadCallBack Only called if the SchemaItem had to be loaded.
+     * @return The SchemaItem if it had to be loaded, otherwise undefined.
+     */
+    async findSchemaItem(name, skipVisitor = false, loadCallBack) {
+        let schemaItem;
+        // TODO: A better solution should be investigated for handling both an alias and the schema name.
+        const [schemaName, itemName] = SchemaReadHelper.resolveSchemaAndItemName(name, this._schema);
+        const isInThisSchema = (this._schema && this._schema.name.toLowerCase() === schemaName.toLowerCase());
+        if (undefined === schemaName || 0 === schemaName.length)
+            throw new ECObjectsError(ECObjectsStatus.InvalidECJson, `The SchemaItem ${name} is invalid without a schema name`);
+        if (isInThisSchema) {
+            schemaItem = await this._schema.getItem(itemName);
+            if (schemaItem)
+                return schemaItem;
+            const foundItem = this._parser.findItem(itemName);
+            if (foundItem) {
+                schemaItem = await this.loadSchemaItem(this._schema, ...foundItem);
+                if (!skipVisitor && schemaItem && this._visitorHelper) {
+                    await this._visitorHelper.visitSchemaPart(schemaItem);
+                }
+                if (loadCallBack && schemaItem)
+                    loadCallBack(schemaItem);
+                return schemaItem;
+            }
+            throw new ECObjectsError(ECObjectsStatus.InvalidECJson, `Unable to locate SchemaItem ${name}.`);
+        }
+        schemaItem = await this._context.getSchemaItem(new SchemaItemKey(itemName, new SchemaKey(schemaName)));
+        if (undefined === schemaItem)
+            throw new ECObjectsError(ECObjectsStatus.InvalidECJson, `Unable to locate SchemaItem ${name}.`);
+        return schemaItem;
+    }
+    /**
+     * Finds the a SchemaItem matching the name first by checking the schema that is being deserialized. If it does
+     * not exist within the schema, the SchemaContext will be searched.
+     * @param name The full (Schema.ItemName) or qualified (alias:ItemName) name of the SchemaItem to search for.
+     * @param skipVisitor Used to break Mixin -appliesTo-> Entity -extends-> Mixin cycle.
+     * @param loadCallBack Only called if the SchemaItem had to be loaded.
+     * @return The SchemaItem if it had to be loaded, otherwise undefined.
+     */
+    findSchemaItemSync(name, skipVisitor = false, loadCallBack) {
+        let schemaItem;
+        // TODO: A better solution should be investigated for handling both an alias and the schema name.
+        const [schemaName, itemName] = SchemaReadHelper.resolveSchemaAndItemName(name, this._schema);
+        const isInThisSchema = (this._schema && this._schema.name.toLowerCase() === schemaName.toLowerCase());
+        if (undefined === schemaName || schemaName.length === 0)
+            throw new ECObjectsError(ECObjectsStatus.InvalidECJson, `The SchemaItem ${name} is invalid without a schema name`);
+        if (isInThisSchema && undefined === this._schema.getItemSync(itemName)) {
+            const foundItem = this._parser.findItem(itemName);
+            if (foundItem) {
+                schemaItem = this.loadSchemaItemSync(this._schema, ...foundItem);
+                if (!skipVisitor && schemaItem && this._visitorHelper) {
+                    this._visitorHelper.visitSchemaPartSync(schemaItem);
+                }
+                if (loadCallBack && schemaItem)
+                    loadCallBack(schemaItem);
+                return schemaItem;
+            }
+            throw new ECObjectsError(ECObjectsStatus.InvalidECJson, `Unable to locate SchemaItem ${name}.`);
+        }
+        schemaItem = this._context.getSchemaItemSync(new SchemaItemKey(itemName, new SchemaKey(schemaName)));
+        if (undefined === schemaItem)
+            throw new ECObjectsError(ECObjectsStatus.InvalidECJson, `Unable to locate SchemaItem ${name}.`);
+        return schemaItem;
+    }
+    /**
+     * Load dependencies on phenomenon and unitSystem for a Unit object and load the Unit from its serialized format.
+     * @param unit The Unit object that we are loading dependencies for and "deserializing into".
+     * @param rawUnit The serialized unit data
+     */
+    async loadUnit(unit, rawUnit) {
+        const unitProps = this._parser.parseUnit(rawUnit);
+        await this.findSchemaItem(unitProps.phenomenon, true);
+        await this.findSchemaItem(unitProps.unitSystem, true);
+        await unit.fromJSON(unitProps);
+    }
+    /**
+     * Load dependencies on phenomenon and unitSystem for a Unit object and load the Unit from its serialized format.
+     * @param unit The Unit object that we are loading dependencies for and "deserializing into".
+     * @param rawUnit The serialized unit data
+     */
+    loadUnitSync(unit, rawUnit) {
+        const unitProps = this._parser.parseUnit(rawUnit);
+        this.findSchemaItemSync(unitProps.phenomenon, true);
+        this.findSchemaItemSync(unitProps.unitSystem, true);
+        unit.fromJSONSync(unitProps);
+    }
+    /**
+     * Load the persistence unit and presentation unit dependencies for a KindOfQuantity object and load the KoQ from its serialized format.
+     * @param koq The KindOfQuantity object that we are loading dependencies for and "deserializing into".
+     * @param rawKoQ The serialized kind of quantity data
+     */
+    async loadKindOfQuantity(koq, rawKoQ) {
+        const koqProps = this._parser.parseKindOfQuantity(rawKoQ);
+        await this.findSchemaItem(koqProps.persistenceUnit);
+        if (undefined !== koqProps.presentationUnits) {
+            for (const formatString of koqProps.presentationUnits) {
+                for (const name of getItemNamesFromFormatString(formatString)) {
+                    await this.findSchemaItem(name);
+                }
+            }
+        }
+        await koq.fromJSON(koqProps);
+    }
+    /**
+     * Load the persistence unit and presentation unit dependencies for a KindOfQuantity object and load the KoQ from its serialized format.
+     * @param koq The KindOfQuantity object that we are loading dependencies for and "deserializing into".
+     * @param rawKoQ The serialized kind of quantity data
+     */
+    loadKindOfQuantitySync(koq, rawKoQ) {
+        const koqProps = this._parser.parseKindOfQuantity(rawKoQ);
+        this.findSchemaItemSync(koqProps.persistenceUnit);
+        if (undefined !== koqProps.presentationUnits) {
+            for (const formatString of koqProps.presentationUnits) {
+                for (const name of getItemNamesFromFormatString(formatString)) {
+                    this.findSchemaItemSync(name);
+                }
+            }
+        }
+        koq.fromJSONSync(koqProps);
+    }
+    /**
+     * Load the phenomenon dependency for a Constant object and load the Constant from its serialized format.
+     * @param constant The Constant object that we are loading the phenomenon dependency for
+     * @param rawConstant The serialized constant data
+     */
+    async loadConstant(constant, rawConstant) {
+        const constantProps = this._parser.parseConstant(rawConstant);
+        await this.findSchemaItem(constantProps.phenomenon, true);
+        await constant.fromJSON(constantProps);
+    }
+    /**
+     * Load the phenomenon dependency for a Constant object and load the Constant from its serialized format.
+     * @param constant The Constant object that we are loading dependencies for and "deserializing into".
+     * @param rawConstant The serialized constant data
+     */
+    loadConstantSync(constant, rawConstant) {
+        const constantProps = this._parser.parseConstant(rawConstant);
+        this.findSchemaItemSync(constantProps.phenomenon, true);
+        constant.fromJSONSync(constantProps);
+    }
+    /**
+     * Load the unit system and invertsUnit dependencies for an Inverted Unit object and load the Inverted Unit from its serialized format.
+     * @param invertedUnit The InvertedUnit object that we are loading dependencies for and "deserializing into".
+     * @param rawInvertedUnit The serialized inverted unit data.
+     */
+    async loadInvertedUnit(invertedUnit, rawInvertedUnit) {
+        const invertedUnitProps = this._parser.parseInvertedUnit(rawInvertedUnit);
+        await this.findSchemaItem(invertedUnitProps.invertsUnit, true);
+        await this.findSchemaItem(invertedUnitProps.unitSystem, true);
+        await invertedUnit.fromJSON(invertedUnitProps);
+    }
+    /**
+     * Load the unit system and invertsUnit dependencies for an Inverted Unit object and load the Inverted Unit from its serialized format.
+     * @param invertedUnit The InvertedUnit object that we are loading dependencies for and "deserializing into".
+     * @param rawInvertedUnit The serialized inverted unit data.
+     */
+    loadInvertedUnitSync(invertedUnit, rawInvertedUnit) {
+        const invertedUnitProps = this._parser.parseInvertedUnit(rawInvertedUnit);
+        this.findSchemaItemSync(invertedUnitProps.invertsUnit, true);
+        this.findSchemaItemSync(invertedUnitProps.unitSystem, true);
+        invertedUnit.fromJSONSync(invertedUnitProps);
+    }
+    /**
+     * Load the unit dependencies for a Format object and load the Format from its serialized format.
+     * @param format The Format object that we are loading dependencies for and "deserializing into".
+     * @param rawFormat The serialized format data.
+     */
+    async loadFormat(format, rawFormat) {
+        const formatProps = this._parser.parseFormat(rawFormat);
+        if (undefined !== formatProps.composite) {
+            const formatUnits = formatProps.composite.units;
+            for (const unit of formatUnits) {
+                await this.findSchemaItem(unit.name, true);
+            }
+        }
+        await format.fromJSON(formatProps);
+    }
+    /**
+     * Load the unit dependencies for a Format object and load the Format from its serialized format.
+     * @param format The Format object that we are loading dependencies for and "deserializing into".
+     * @param rawFormat The serialized format data.
+     */
+    loadFormatSync(format, rawFormat) {
+        const formatProps = this._parser.parseFormat(rawFormat);
+        if (undefined !== formatProps.composite) {
+            const formatUnits = formatProps.composite.units;
+            for (const unit of formatUnits) {
+                this.findSchemaItemSync(unit.name, true);
+            }
+        }
+        format.fromJSONSync(formatProps);
+    }
+    /**
+     * Load the base class and property type dependencies for an ECClass object and load the ECClass (and its properties) from its serialized format.
+     * @param classObj The ECClass object that we are loading dependencies for and "deserializing into".
+     * @param classProps The parsed class props object.
+     * @param rawClass The serialized class data.
+     */
+    async loadClass(classObj, classProps, rawClass) {
+        const baseClassLoaded = async (baseClass) => {
+            if (this._visitorHelper)
+                await this._visitorHelper.visitSchemaPart(baseClass);
+        };
+        // Load base class first
+        if (undefined !== classProps.baseClass) {
+            await this.findSchemaItem(classProps.baseClass, true, baseClassLoaded);
+        }
+        // Now deserialize the class itself, *before* any properties
+        // (We need to do this to break Entity -navProp-> Relationship -constraint-> Entity cycle.)
+        await classObj.fromJSON(classProps);
+        for (const [propName, propType, rawProp] of this._parser.getProperties(rawClass, classObj.fullName)) {
+            await this.loadPropertyTypes(classObj, propName, propType, rawProp);
+        }
+        await this.loadCustomAttributes(classObj, this._parser.getClassCustomAttributeProviders(rawClass));
+    }
+    /**
+     * Load the base class and property type dependencies for an ECClass object and load the ECClass (and its properties) from its serialized format.
+     * @param classObj The ECClass object that we are loading dependencies for and "deserializing into".
+     * @param classProps The parsed class props object.
+     * @param rawClass The serialized class data.
+     */
+    loadClassSync(classObj, classProps, rawClass) {
+        const baseClassLoaded = async (baseClass) => {
+            if (this._visitorHelper)
+                this._visitorHelper.visitSchemaPartSync(baseClass);
+        };
+        // Load base class first
+        if (undefined !== classProps.baseClass) {
+            this.findSchemaItemSync(classProps.baseClass, true, baseClassLoaded);
+        }
+        // Now deserialize the class itself, *before* any properties
+        // (We need to do this to break Entity -navProp-> Relationship -constraint-> Entity cycle.)
+        classObj.fromJSONSync(classProps);
+        for (const [propName, propType, rawProp] of this._parser.getProperties(rawClass, classObj.fullName)) {
+            this.loadPropertyTypesSync(classObj, propName, propType, rawProp);
+        }
+        this.loadCustomAttributesSync(classObj, this._parser.getClassCustomAttributeProviders(rawClass));
+    }
+    /**
+     * Load the mixin, base class, and property type dependencies for an EntityClass object and load the EntityClass (and properties) from its serialized format.
+     * @param entity The EntityClass that we are loading dependencies for and "deserializing into".
+     * @param rawEntity The serialized entity class data.
+     */
+    async loadEntityClass(entity, rawEntity) {
+        const entityClassProps = this._parser.parseEntityClass(rawEntity);
+        // Load Mixin classes first
+        if (undefined !== entityClassProps.mixins) {
+            for (const mixinName of entityClassProps.mixins)
+                await this.findSchemaItem(mixinName);
+        }
+        await this.loadClass(entity, entityClassProps, rawEntity);
+    }
+    /**
+     * Load the mixin, base class, and property type dependencies for an EntityClass object and load the EntityClass (and properties) from its serialized format.
+     * @param entity The EntityClass that we are loading dependencies for and "deserializing into".
+     * @param rawEntity The serialized entity class data.
+     */
+    loadEntityClassSync(entity, rawEntity) {
+        const entityClassProps = this._parser.parseEntityClass(rawEntity);
+        // Load Mixin classes first
+        if (undefined !== entityClassProps.mixins) {
+            for (const mixinName of entityClassProps.mixins)
+                this.findSchemaItemSync(mixinName);
+        }
+        this.loadClassSync(entity, entityClassProps, rawEntity);
+    }
+    /**
+     * Load the appliesTo class, base class, and property type dependencies for a Mixin object and load the Mixin (and properties) from its serialized format.
+     * @param mixin The Mixin that we are loading dependencies for and "deserializing into".
+     * @param rawMixin The serialized mixin data.
+     */
+    async loadMixin(mixin, rawMixin) {
+        const mixinProps = this._parser.parseMixin(rawMixin);
+        const appliesToLoaded = async (appliesToClass) => {
+            if (this._visitorHelper)
+                await this._visitorHelper.visitSchemaPart(appliesToClass);
+        };
+        await this.findSchemaItem(mixinProps.appliesTo, true, appliesToLoaded);
+        await this.loadClass(mixin, mixinProps, rawMixin);
+    }
+    /**
+     * Load the appliesTo class, base class, and property type dependencies for a Mixin object and load the Mixin (and properties) from its serialized format.
+     * @param mixin The Mixin that we are loading dependencies for and "deserializing into".
+     * @param rawMixin The serialized mixin data.
+     */
+    loadMixinSync(mixin, rawMixin) {
+        const mixinProps = this._parser.parseMixin(rawMixin);
+        const appliesToLoaded = async (appliesToClass) => {
+            if (this._visitorHelper)
+                await this._visitorHelper.visitSchemaPart(appliesToClass);
+        };
+        this.findSchemaItemSync(mixinProps.appliesTo, true, appliesToLoaded);
+        this.loadClassSync(mixin, mixinProps, rawMixin);
+    }
+    /**
+     * Load the relationship constraint, base class, and property type dependencies for a RelationshipClass object and load the RelationshipClass (and properties) from its serialized format.
+     * @param rel The RelationshipClass that we are loading dependencies for and "deserializing into".
+     * @param rawRel The serialized relationship class data.
+     */
+    async loadRelationshipClass(rel, rawRel) {
+        const relationshipClassProps = this._parser.parseRelationshipClass(rawRel);
+        await this.loadClass(rel, relationshipClassProps, rawRel);
+        await this.loadRelationshipConstraint(rel.source, relationshipClassProps.source);
+        await this.loadRelationshipConstraint(rel.target, relationshipClassProps.target);
+        const [sourceCustomAttributes, targetCustomAttributes] = this._parser.getRelationshipConstraintCustomAttributeProviders(rawRel);
+        await this.loadCustomAttributes(rel.source, sourceCustomAttributes);
+        await this.loadCustomAttributes(rel.target, targetCustomAttributes);
+    }
+    /**
+     * Load the relationship constraint, base class, and property type dependencies for a RelationshipClass object and load the RelationshipClass (and properties) from its serialized format.
+     * @param rel The RelationshipClass that we are loading dependencies for and "deserializing into".
+     * @param rawRel The serialized relationship class data.
+     */
+    loadRelationshipClassSync(rel, rawRel) {
+        const relationshipClassProps = this._parser.parseRelationshipClass(rawRel);
+        this.loadClassSync(rel, relationshipClassProps, rawRel);
+        this.loadRelationshipConstraintSync(rel.source, relationshipClassProps.source);
+        this.loadRelationshipConstraintSync(rel.target, relationshipClassProps.target);
+        const [sourceCustomAttributes, targetCustomAttributes] = this._parser.getRelationshipConstraintCustomAttributeProviders(rawRel);
+        this.loadCustomAttributesSync(rel.source, sourceCustomAttributes);
+        this.loadCustomAttributesSync(rel.target, targetCustomAttributes);
+    }
+    /**
+     * Load the abstract constraint and constraint class dependencies for a RelationshipConstraint object and load the RelationshipConstraint from its parsed props.
+     * @param relConstraint The RelationshipConstraint that we are loading dependencies for and "deserializing into".
+     * @param props The parsed relationship constraint props.
+     */
+    async loadRelationshipConstraint(relConstraint, props) {
+        if (undefined !== props.abstractConstraint) {
+            await this.findSchemaItem(props.abstractConstraint);
+        }
+        if (undefined !== props.constraintClasses) { // TODO: this should be required
+            for (const constraintClass of props.constraintClasses) {
+                await this.findSchemaItem(constraintClass);
+            }
+        }
+        await relConstraint.fromJSON(props);
+    }
+    /**
+     * Load the abstract constraint and constraint class dependencies for a RelationshipConstraint object and load the RelationshipConstraint from its parsed props.
+     * @param relConstraint The RelationshipConstraint that we are loading dependencies for and "deserializing into".
+     * @param props The parsed relationship constraint props.
+     */
+    loadRelationshipConstraintSync(relConstraint, props) {
+        if (undefined !== props.abstractConstraint) {
+            this.findSchemaItemSync(props.abstractConstraint);
+        }
+        if (undefined !== props.constraintClasses) {
+            for (const constraintClass of props.constraintClasses) {
+                this.findSchemaItemSync(constraintClass);
+            }
+        }
+        relConstraint.fromJSONSync(props);
+    }
+    /**
+     * Load the type dependencies for a serialized property, then creates and deserialized the Property object in the given ECClass.
+     * @param classObj The ECClass that the Property should be created in.
+     * @param propName The name of the Property.
+     * @param propType The (serialized string) kind of property to create.
+     * @param rawProperty The serialized property data.
+     */
+    async loadPropertyTypes(classObj, propName, propType, rawProperty) {
+        const loadTypeName = async (typeName) => {
+            if (undefined === parsePrimitiveType(typeName))
+                await this.findSchemaItem(typeName);
+        };
+        const lowerCasePropType = propType.toLowerCase();
+        switch (lowerCasePropType) {
+            case "primitiveproperty":
+                const primPropertyProps = this._parser.parsePrimitiveProperty(rawProperty);
+                await loadTypeName(primPropertyProps.typeName);
+                const primProp = await classObj.createPrimitiveProperty(propName, primPropertyProps.typeName);
+                return this.loadProperty(primProp, primPropertyProps, rawProperty);
+            case "structproperty":
+                const structPropertyProps = this._parser.parseStructProperty(rawProperty);
+                await loadTypeName(structPropertyProps.typeName);
+                const structProp = await classObj.createStructProperty(propName, structPropertyProps.typeName);
+                return this.loadProperty(structProp, structPropertyProps, rawProperty);
+            case "primitivearrayproperty":
+                const primArrPropertyProps = this._parser.parsePrimitiveArrayProperty(rawProperty);
+                await loadTypeName(primArrPropertyProps.typeName);
+                const primArrProp = await classObj.createPrimitiveArrayProperty(propName, primArrPropertyProps.typeName);
+                return this.loadProperty(primArrProp, primArrPropertyProps, rawProperty);
+            case "structarrayproperty":
+                const structArrPropertyProps = this._parser.parseStructArrayProperty(rawProperty);
+                await loadTypeName(structArrPropertyProps.typeName);
+                const structArrProp = await classObj.createStructArrayProperty(propName, structArrPropertyProps.typeName);
+                return this.loadProperty(structArrProp, structArrPropertyProps, rawProperty);
+            case "navigationproperty":
+                if (classObj.schemaItemType !== SchemaItemType.EntityClass && classObj.schemaItemType !== SchemaItemType.RelationshipClass && classObj.schemaItemType !== SchemaItemType.Mixin)
+                    throw new ECObjectsError(ECObjectsStatus.InvalidECJson, `The Navigation Property ${classObj.name}.${propName} is invalid, because only EntityClasses, Mixins, and RelationshipClasses can have NavigationProperties.`);
+                const navPropertyProps = this._parser.parseNavigationProperty(rawProperty);
+                await this.findSchemaItem(navPropertyProps.relationshipName);
+                const navProp = await classObj.createNavigationProperty(propName, navPropertyProps.relationshipName, navPropertyProps.direction);
+                return this.loadProperty(navProp, navPropertyProps, rawProperty);
+        }
+    }
+    /**
+     * Load the type dependencies for a serialized property, then creates and deserialized the Property object in the given ECClass.
+     * @param classObj The ECClass that the Property should be created in.
+     * @param propName The name of the Property.
+     * @param propType The (serialized string) kind of property to create.
+     * @param rawProperty The serialized property data.
+     */
+    loadPropertyTypesSync(classObj, propName, propType, rawProperty) {
+        const loadTypeName = (typeName) => {
+            if (undefined === parsePrimitiveType(typeName))
+                this.findSchemaItemSync(typeName);
+        };
+        const lowerCasePropType = propType.toLowerCase();
+        switch (lowerCasePropType) {
+            case "primitiveproperty":
+                const primPropertyProps = this._parser.parsePrimitiveProperty(rawProperty);
+                loadTypeName(primPropertyProps.typeName);
+                const primProp = classObj.createPrimitivePropertySync(propName, primPropertyProps.typeName);
+                return this.loadPropertySync(primProp, primPropertyProps, rawProperty);
+            case "structproperty":
+                const structPropertyProps = this._parser.parseStructProperty(rawProperty);
+                loadTypeName(structPropertyProps.typeName);
+                const structProp = classObj.createStructPropertySync(propName, structPropertyProps.typeName);
+                return this.loadPropertySync(structProp, structPropertyProps, rawProperty);
+            case "primitivearrayproperty":
+                const primArrPropertyProps = this._parser.parsePrimitiveArrayProperty(rawProperty);
+                loadTypeName(primArrPropertyProps.typeName);
+                const primArrProp = classObj.createPrimitiveArrayPropertySync(propName, primArrPropertyProps.typeName);
+                return this.loadPropertySync(primArrProp, primArrPropertyProps, rawProperty);
+            case "structarrayproperty":
+                const structArrPropertyProps = this._parser.parseStructArrayProperty(rawProperty);
+                loadTypeName(structArrPropertyProps.typeName);
+                const structArrProp = classObj.createStructArrayPropertySync(propName, structArrPropertyProps.typeName);
+                return this.loadPropertySync(structArrProp, structArrPropertyProps, rawProperty);
+            case "navigationproperty":
+                if (classObj.schemaItemType !== SchemaItemType.EntityClass && classObj.schemaItemType !== SchemaItemType.RelationshipClass && classObj.schemaItemType !== SchemaItemType.Mixin)
+                    throw new ECObjectsError(ECObjectsStatus.InvalidECJson, `The Navigation Property ${classObj.name}.${propName} is invalid, because only EntityClasses, Mixins, and RelationshipClasses can have NavigationProperties.`);
+                const navPropertyProps = this._parser.parseNavigationProperty(rawProperty);
+                this.findSchemaItemSync(navPropertyProps.relationshipName);
+                const navProp = classObj.createNavigationPropertySync(propName, navPropertyProps.relationshipName, navPropertyProps.direction);
+                return this.loadPropertySync(navProp, navPropertyProps, rawProperty);
+        }
+    }
+    /**
+     * Load the propertyCategory, kindOfQuantity, and customAttribute dependencies for a Property object and load the Property from its parsed props.
+     * @param propertyObj The Property that we are loading dependencies for and "deserializing into".
+     * @param props The parsed property props.
+     * @param rawProperty The serialized property data.
+     */
+    async loadProperty(propertyObj, props, rawProperty) {
+        if (undefined !== props.category) {
+            await this.findSchemaItem(props.category);
+        }
+        if (undefined !== props.kindOfQuantity) {
+            await this.findSchemaItem(props.kindOfQuantity);
+        }
+        await propertyObj.fromJSON(props);
+        await this.loadCustomAttributes(propertyObj, this._parser.getPropertyCustomAttributeProviders(rawProperty));
+    }
+    /**
+     * Load the propertyCategory, kindOfQuantity, and customAttribute dependencies for a Property object and load the Property from its parsed props.
+     * @param propertyObj The Property that we are loading dependencies for and "deserializing into".
+     * @param props The parsed property props.
+     * @param rawProperty The serialized property data.
+     */
+    loadPropertySync(propertyObj, props, rawProperty) {
+        if (undefined !== props.category) {
+            this.findSchemaItemSync(props.category);
+        }
+        if (undefined !== props.kindOfQuantity) {
+            this.findSchemaItemSync(props.kindOfQuantity);
+        }
+        propertyObj.fromJSONSync(props);
+        this.loadCustomAttributesSync(propertyObj, this._parser.getPropertyCustomAttributeProviders(rawProperty));
+    }
+    /**
+     * Load the customAttribute class dependencies for a set of CustomAttribute objects and add
+     * them to a given custom attribute container.
+     * @param container The CustomAttributeContainer that each CustomAttribute will be added to.
+     * @param customAttributes An iterable set of parsed CustomAttribute objects.
+     */
+    async loadCustomAttributes(container, caProviders) {
+        for (const providerTuple of caProviders) {
+            // First tuple entry is the CA class name.
+            const caClass = await this.findSchemaItem(providerTuple[0]);
+            // If custom attribute exist within the context and is referenced, validate the reference is defined in the container's schema
+            if (caClass && caClass.key.schemaName !== container.schema.name &&
+                !container.schema.getReferenceSync(caClass.key.schemaName)) {
+                throw new ECObjectsError(ECObjectsStatus.InvalidECJson, `Unable to load custom attribute ${caClass.fullName} from container ${container.fullName}, ${caClass.key.schemaName} reference not defined`);
+            }
+            // Second tuple entry ia a function that provides the CA instance.
+            const provider = providerTuple[1];
+            const customAttribute = provider(caClass);
+            container.addCustomAttribute(customAttribute);
+        }
+    }
+    /**
+     * Load the customAttribute class dependencies for a set of CustomAttribute objects and add them to a given custom attribute container.
+     * @param container The CustomAttributeContainer that each CustomAttribute will be added to.
+     * @param customAttributes An iterable set of parsed CustomAttribute objects.
+     */
+    loadCustomAttributesSync(container, caProviders) {
+        for (const providerTuple of caProviders) {
+            // First tuple entry is the CA class name.
+            const caClass = this.findSchemaItemSync(providerTuple[0]);
+            // Second tuple entry ia a function that provides the CA instance.
+            const provider = providerTuple[1];
+            const customAttribute = provider(caClass);
+            container.addCustomAttribute(customAttribute);
+        }
+    }
+}
+//# sourceMappingURL=Helper.js.map