@itwin/imodel-transformer 0.0.1-dev.0

package/lib/cjs/IModelExporter.js

@@ -0,0 +1,804 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module iModels
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChangedInstanceIds = exports.ChangedInstanceOps = exports.IModelExporter = exports.IModelExportHandler = void 0;
+const core_bentley_1 = require("@itwin/core-bentley");
+const ecschema_metadata_1 = require("@itwin/ecschema-metadata");
+const core_common_1 = require("@itwin/core-common");
+const TransformerLoggerCategory_1 = require("./TransformerLoggerCategory");
+const core_backend_1 = require("@itwin/core-backend");
+const loggerCategory = TransformerLoggerCategory_1.TransformerLoggerCategory.IModelExporter;
+/** Handles the events generated by IModelExporter.
+ * @note Change information is available when `IModelExportHandler` methods are invoked via [IModelExporter.exportChanges]($transformer), but not available when invoked via [IModelExporter.exportAll]($transformer).
+ * @note The handler is intended to be owned by (registered with) and called from the IModelExporter exclusively
+ * @see [iModel Transformation and Data Exchange]($docs/learning/transformer/index.md), [IModelExporter]($transformer)
+ * @beta
+ */
+class IModelExportHandler {
+    /** If `true` is returned, then the CodeSpec will be exported.
+     * @note This method can optionally be overridden to exclude an individual CodeSpec from the export. The base implementation always returns `true`.
+     */
+    shouldExportCodeSpec(_codeSpec) { return true; }
+    /** Called when a CodeSpec should be exported.
+     * @param codeSpec The CodeSpec to export
+     * @param isUpdate If defined, then `true` indicates an UPDATE operation while `false` indicates an INSERT operation. If not defined, then INSERT vs. UPDATE is not known.
+     * @note This should be overridden to actually do the export.
+     */
+    onExportCodeSpec(_codeSpec, _isUpdate) { }
+    /** Called when a font should be exported.
+     * @param font The font to export
+     * @param isUpdate If defined, then `true` indicates an UPDATE operation while `false` indicates an INSERT operation. If not defined, then INSERT vs. UPDATE is not known.
+     * @note This should be overridden to actually do the export.
+     */
+    onExportFont(_font, _isUpdate) { }
+    /** Called when a model should be exported.
+     * @param model The model to export
+     * @param isUpdate If defined, then `true` indicates an UPDATE operation while `false` indicates an INSERT operation. If not defined, then INSERT vs. UPDATE is not known.
+     * @note This should be overridden to actually do the export.
+     */
+    onExportModel(_model, _isUpdate) { }
+    /** Called when a model should be deleted. */
+    onDeleteModel(_modelId) { }
+    /** If `true` is returned, then the element will be exported.
+     * @note This method can optionally be overridden to exclude an individual Element (and its children and ElementAspects) from the export. The base implementation always returns `true`.
+     */
+    shouldExportElement(_element) { return true; }
+    /** Called when an element should be exported.
+     * @param element The element to export
+     * @param isUpdate If defined, then `true` indicates an UPDATE operation while `false` indicates an INSERT operation. If not defined, then INSERT vs. UPDATE is not known.
+     * @note This should be overridden to actually do the export.
+     */
+    onExportElement(_element, _isUpdate) { }
+    /**
+     * Do any asynchronous actions before exporting an element
+     * @note Do not implement this handler manually, it is internal, it will be removed.
+     *       This will become a part of onExportElement once that becomes async
+     * @internal
+     */
+    async preExportElement(_element) { }
+    /** Called when an element should be deleted. */
+    onDeleteElement(_elementId) { }
+    /** If `true` is returned, then the ElementAspect will be exported.
+     * @note This method can optionally be overridden to exclude an individual ElementAspect from the export. The base implementation always returns `true`.
+     */
+    shouldExportElementAspect(_aspect) { return true; }
+    /** Called when an ElementUniqueAspect should be exported.
+     * @param aspect The ElementUniqueAspect to export
+     * @param isUpdate If defined, then `true` indicates an UPDATE operation while `false` indicates an INSERT operation. If not defined, then INSERT vs. UPDATE is not known.
+     * @note This should be overridden to actually do the export.
+     */
+    onExportElementUniqueAspect(_aspect, _isUpdate) { }
+    /** Called when ElementMultiAspects should be exported.
+     * @note This should be overridden to actually do the export.
+     */
+    onExportElementMultiAspects(_aspects) { }
+    /** If `true` is returned, then the relationship will be exported.
+     * @note This method can optionally be overridden to exclude an individual CodeSpec from the export. The base implementation always returns `true`.
+     */
+    shouldExportRelationship(_relationship) { return true; }
+    /** Called when a Relationship should be exported.
+     * @param relationship The Relationship to export
+     * @param isUpdate If defined, then `true` indicates an UPDATE operation while `false` indicates an INSERT operation. If not defined, then INSERT vs. UPDATE is not known.
+     * @note This should be overridden to actually do the export.
+     */
+    onExportRelationship(_relationship, _isUpdate) { }
+    /** Called when a relationship should be deleted. */
+    onDeleteRelationship(_relInstanceId) { }
+    /** If `true` is returned, then the schema will be exported.
+     * @note This method can optionally be overridden to exclude an individual schema from the export. The base implementation always returns `true`.
+     */
+    shouldExportSchema(_schemaKey) { return true; }
+    /** Called when a schema should be exported.
+     * @param schema The schema to export
+     * @note This should be overridden to actually do the export.
+     * @note return an [[ExportSchemaResult]] with a `schemaPath` property to notify overrides that call `super`
+     *       where a schema was written for import.
+     */
+    async onExportSchema(_schema) { }
+    /** This method is called when IModelExporter has made incremental progress based on the [[IModelExporter.progressInterval]] setting.
+     * This method is `async` to make it easier to integrate with asynchronous status and health reporting services.
+     * @note A subclass may override this method to report custom progress. The base implementation does nothing.
+     */
+    async onProgress() { }
+}
+exports.IModelExportHandler = IModelExportHandler;
+/** Base class for exporting data from an iModel.
+ * @note Most uses cases will not require a custom subclass of `IModelExporter`. Instead, it is more typical to subclass/customize [IModelExportHandler]($transformer).
+ * @see [iModel Transformation and Data Exchange]($docs/learning/transformer/index.md), [[registerHandler]], [IModelTransformer]($transformer), [IModelImporter]($transformer)
+ * @beta
+ */
+class IModelExporter {
+    /** Construct a new IModelExporter
+     * @param sourceDb The source IModelDb
+     * @see registerHandler
+     */
+    constructor(sourceDb) {
+        /** A flag that indicates whether element GeometryStreams are loaded or not.
+         * @note As an optimization, exporters that don't need geometry can set this flag to `false`. The default is `true`.
+         * @note The transformer by default sets this to `false` as an optimization.
+         * @note This implies the `wantBRepData` option when loading elements.
+         * @see [ElementLoadProps.wantGeometry]($common)
+         */
+        this.wantGeometry = true;
+        /** A flag that indicates whether template models should be exported or not. The default is `true`.
+         * @note If only exporting *instances* then template models can be skipped since they are just definitions that are cloned to create new instances.
+         * @see [Model.isTemplate]($backend)
+         */
+        this.wantTemplateModels = true;
+        /** A flag that indicates whether *system* schemas should be exported or not. The default is `true` (previously false).
+         * This can be set to false for the legacy default behavior, but it may cause errors during schema processing in some cases.
+         * @see [[exportSchemas]]
+         */
+        this.wantSystemSchemas = true;
+        /** A flag that determines whether this IModelExporter should visit Elements or not. The default is `true`.
+         * @note This flag is available as an optimization when the exporter doesn't need to visit elements, so can skip loading them.
+         */
+        this.visitElements = true;
+        /** A flag that determines whether this IModelExporter should visit Relationships or not. The default is `true`.
+         * @note This flag is available as an optimization when the exporter doesn't need to visit relationships, so can skip loading them.
+         */
+        this.visitRelationships = true;
+        /** The number of entities exported before incremental progress should be reported via the [[onProgress]] callback. */
+        this.progressInterval = 1000;
+        /** Tracks the current total number of entities exported. */
+        this._progressCounter = 0;
+        /** The set of CodeSpecs to exclude from the export. */
+        this._excludedCodeSpecNames = new Set();
+        /** The set of specific Elements to exclude from the export. */
+        this._excludedElementIds = new Set();
+        /** The set of Categories where Elements in that Category will be excluded from transformation to the target iModel. */
+        this._excludedElementCategoryIds = new Set();
+        /** The set of classes of Elements that will be excluded (polymorphically) from transformation to the target iModel. */
+        this._excludedElementClasses = new Set();
+        /** The set of classes of ElementAspects that will be excluded (polymorphically) from transformation to the target iModel. */
+        this._excludedElementAspectClasses = new Set();
+        /** The set of classFullNames for ElementAspects that will be excluded from transformation to the target iModel. */
+        this._excludedElementAspectClassFullNames = new Set();
+        /** The set of classes of Relationships that will be excluded (polymorphically) from transformation to the target iModel. */
+        this._excludedRelationshipClasses = new Set();
+        this._yieldManager = new core_bentley_1.YieldManager();
+        this.sourceDb = sourceDb;
+    }
+    /**
+     * Retrieve the cached entity change information.
+     * @note This will only be initialized after [IModelExporter.exportChanges] is invoked.
+    */
+    get sourceDbChanges() {
+        return this._sourceDbChanges;
+    }
+    /** The handler called by this IModelExporter. */
+    get handler() {
+        if (undefined === this._handler) {
+            throw new Error("IModelExportHandler not registered");
+        }
+        return this._handler;
+    }
+    /** Register the handler that will be called by IModelExporter. */
+    registerHandler(handler) {
+        this._handler = handler;
+    }
+    /** Add a rule to exclude a CodeSpec */
+    excludeCodeSpec(codeSpecName) {
+        this._excludedCodeSpecNames.add(codeSpecName);
+    }
+    /** Add a rule to exclude a specific Element. */
+    excludeElement(elementId) {
+        this._excludedElementIds.add(elementId);
+    }
+    /** Add a rule to exclude all Elements in a specified Category. */
+    excludeElementsInCategory(categoryId) {
+        this._excludedElementCategoryIds.add(categoryId);
+    }
+    /** Add a rule to exclude all Elements of a specified class. */
+    excludeElementClass(classFullName) {
+        this._excludedElementClasses.add(this.sourceDb.getJsClass(classFullName));
+    }
+    /** Add a rule to exclude all ElementAspects of a specified class. */
+    excludeElementAspectClass(classFullName) {
+        this._excludedElementAspectClassFullNames.add(classFullName); // allows non-polymorphic exclusion before query
+        this._excludedElementAspectClasses.add(this.sourceDb.getJsClass(classFullName)); // allows polymorphic exclusion after query/load
+    }
+    /** Add a rule to exclude all Relationships of a specified class. */
+    excludeRelationshipClass(classFullName) {
+        this._excludedRelationshipClasses.add(this.sourceDb.getJsClass(classFullName));
+    }
+    /** Export all entity instance types from the source iModel.
+     * @note [[exportSchemas]] must be called separately.
+     */
+    async exportAll() {
+        await this.exportCodeSpecs();
+        await this.exportFonts();
+        await this.exportModel(core_common_1.IModel.repositoryModelId);
+        await this.exportRelationships(core_backend_1.ElementRefersToElements.classFullName);
+    }
+    /** Export changes from the source iModel.
+     * @param user The user
+     * @param startChangesetId Include changes from this changeset up through and including the current changeset.
+     * If this parameter is not provided, then just the current changeset will be exported.
+     * @note To form a range of versions to export, set `startChangesetId` for the start (inclusive) of the desired range and open the source iModel as of the end (inclusive) of the desired range.
+     */
+    async exportChanges(user, startChangesetId) {
+        if (!this.sourceDb.isBriefcaseDb()) {
+            throw new core_common_1.IModelError(core_bentley_1.IModelStatus.BadRequest, "Must be a briefcase to export changes");
+        }
+        if ("" === this.sourceDb.changeset.id) {
+            await this.exportAll(); // no changesets, so revert to exportAll
+            return;
+        }
+        if (undefined === startChangesetId) {
+            startChangesetId = this.sourceDb.changeset.id;
+        }
+        this._sourceDbChanges = await ChangedInstanceIds.initialize(user, this.sourceDb, startChangesetId);
+        await this.exportCodeSpecs();
+        await this.exportFonts();
+        await this.exportModelContents(core_common_1.IModel.repositoryModelId);
+        await this.exportSubModels(core_common_1.IModel.repositoryModelId);
+        await this.exportRelationships(core_backend_1.ElementRefersToElements.classFullName);
+        // handle deletes
+        if (this.visitElements) {
+            // must delete models first since they have a constraint on the submodeling element which may also be deleted
+            for (const modelId of this._sourceDbChanges.model.deleteIds) {
+                this.handler.onDeleteModel(modelId);
+            }
+            for (const elementId of this._sourceDbChanges.element.deleteIds) {
+                // We don't know how the handler wants to handle deletions, and we don't have enough information
+                // to know if deleted entities were related, so when processing changes, ignore errors from deletion.
+                // Technically, to keep the ignored error scope small, we ignore only the error of looking up a missing element,
+                // that approach works at least for the IModelTransformer.
+                // In the future, the handler may be responsible for doing the work of finding out which elements were cascade deleted,
+                // and returning them for the exporter to use to avoid double-deleting with error ignoring
+                try {
+                    this.handler.onDeleteElement(elementId);
+                }
+                catch (err) {
+                    const isMissingErr = err instanceof core_common_1.IModelError && err.errorNumber === core_bentley_1.IModelStatus.NotFound;
+                    if (!isMissingErr)
+                        throw err;
+                }
+            }
+        }
+        if (this.visitRelationships) {
+            for (const relInstanceId of this._sourceDbChanges.relationship.deleteIds) {
+                this.handler.onDeleteRelationship(relInstanceId);
+            }
+        }
+    }
+    /** Export schemas from the source iModel.
+     * @note This must be called separately from [[exportAll]] or [[exportChanges]].
+     */
+    async exportSchemas() {
+        /* eslint-disable @typescript-eslint/indent */
+        const sql = `
+      SELECT s.Name, s.VersionMajor, s.VersionWrite, s.VersionMinor
+      FROM ECDbMeta.ECSchemaDef s
+      ${this.wantSystemSchemas ? "" : `
+      WHERE ECInstanceId >= (SELECT ECInstanceId FROM ECDbMeta.ECSchemaDef WHERE Name='BisCore')
+      `}
+      ORDER BY ECInstanceId
+    `;
+        /* eslint-enable @typescript-eslint/indent */
+        const schemaNamesToExport = [];
+        this.sourceDb.withPreparedStatement(sql, (statement) => {
+            while (core_bentley_1.DbResult.BE_SQLITE_ROW === statement.step()) {
+                const schemaName = statement.getValue(0).getString();
+                const versionMajor = statement.getValue(1).getInteger();
+                const versionWrite = statement.getValue(2).getInteger();
+                const versionMinor = statement.getValue(3).getInteger();
+                const schemaKey = new ecschema_metadata_1.SchemaKey(schemaName, new ecschema_metadata_1.ECVersion(versionMajor, versionWrite, versionMinor));
+                if (this.handler.shouldExportSchema(schemaKey)) {
+                    schemaNamesToExport.push(schemaName);
+                }
+            }
+        });
+        if (schemaNamesToExport.length === 0)
+            return;
+        const schemaLoader = new ecschema_metadata_1.SchemaLoader((name) => this.sourceDb.getSchemaProps(name));
+        await Promise.all(schemaNamesToExport.map(async (schemaName) => {
+            const schema = schemaLoader.getSchema(schemaName);
+            core_bentley_1.Logger.logTrace(loggerCategory, `exportSchema(${schemaName})`);
+            return this.handler.onExportSchema(schema);
+        }));
+    }
+    /** For logging, indicate the change type if known. */
+    getChangeOpSuffix(isUpdate) {
+        return isUpdate ? " UPDATE" : undefined === isUpdate ? "" : " INSERT";
+    }
+    /** Export all CodeSpecs from the source iModel.
+     * @note This method is called from [[exportChanges]] and [[exportAll]], so it only needs to be called directly when exporting a subset of an iModel.
+     */
+    async exportCodeSpecs() {
+        core_bentley_1.Logger.logTrace(loggerCategory, `exportCodeSpecs()`);
+        const sql = `SELECT Name FROM BisCore:CodeSpec ORDER BY ECInstanceId`;
+        await this.sourceDb.withPreparedStatement(sql, async (statement) => {
+            while (core_bentley_1.DbResult.BE_SQLITE_ROW === statement.step()) {
+                const codeSpecName = statement.getValue(0).getString();
+                await this.exportCodeSpecByName(codeSpecName);
+            }
+        });
+    }
+    /** Export a single CodeSpec from the source iModel.
+     * @note This method is called from [[exportChanges]] and [[exportAll]], so it only needs to be called directly when exporting a subset of an iModel.
+     */
+    async exportCodeSpecByName(codeSpecName) {
+        const codeSpec = this.sourceDb.codeSpecs.getByName(codeSpecName);
+        let isUpdate;
+        if (undefined !== this._sourceDbChanges) { // is changeset information available?
+            if (this._sourceDbChanges.codeSpec.insertIds.has(codeSpec.id)) {
+                isUpdate = false;
+            }
+            else if (this._sourceDbChanges.codeSpec.updateIds.has(codeSpec.id)) {
+                isUpdate = true;
+            }
+            else {
+                return; // not in changeset, don't export
+            }
+        }
+        // passed changeset test, now apply standard exclusion rules
+        if (this._excludedCodeSpecNames.has(codeSpec.name)) {
+            core_bentley_1.Logger.logInfo(loggerCategory, `Excluding CodeSpec: ${codeSpec.name}`);
+            return;
+        }
+        // CodeSpec has passed standard exclusion rules, now give handler a chance to accept/reject export
+        if (this.handler.shouldExportCodeSpec(codeSpec)) {
+            core_bentley_1.Logger.logTrace(loggerCategory, `exportCodeSpec(${codeSpecName})${this.getChangeOpSuffix(isUpdate)}`);
+            this.handler.onExportCodeSpec(codeSpec, isUpdate);
+            return this.trackProgress();
+        }
+    }
+    /** Export a single CodeSpec from the source iModel.
+     * @note This method is called from [[exportChanges]] and [[exportAll]], so it only needs to be called directly when exporting a subset of an iModel.
+     */
+    async exportCodeSpecById(codeSpecId) {
+        const codeSpec = this.sourceDb.codeSpecs.getById(codeSpecId);
+        return this.exportCodeSpecByName(codeSpec.name);
+    }
+    /** Export all fonts from the source iModel.
+     * @note This method is called from [[exportChanges]] and [[exportAll]], so it only needs to be called directly when exporting a subset of an iModel.
+     */
+    async exportFonts() {
+        core_bentley_1.Logger.logTrace(loggerCategory, `exportFonts()`);
+        for (const font of this.sourceDb.fontMap.fonts.values()) {
+            await this.exportFontByNumber(font.id);
+        }
+    }
+    /** Export a single font from the source iModel.
+     * @note This method is called from [[exportChanges]] and [[exportAll]], so it only needs to be called directly when exporting a subset of an iModel.
+     */
+    async exportFontByName(fontName) {
+        core_bentley_1.Logger.logTrace(loggerCategory, `exportFontByName(${fontName})`);
+        const font = this.sourceDb.fontMap.getFont(fontName);
+        if (undefined !== font) {
+            await this.exportFontByNumber(font.id);
+        }
+    }
+    /** Export a single font from the source iModel.
+     * @note This method is called from [[exportChanges]] and [[exportAll]], so it only needs to be called directly when exporting a subset of an iModel.
+     */
+    async exportFontByNumber(fontNumber) {
+        let isUpdate;
+        if (undefined !== this._sourceDbChanges) { // is changeset information available?
+            const fontId = core_bentley_1.Id64.fromUint32Pair(fontNumber, 0); // changeset information uses Id64String, not number
+            if (this._sourceDbChanges.font.insertIds.has(fontId)) {
+                isUpdate = false;
+            }
+            else if (this._sourceDbChanges.font.updateIds.has(fontId)) {
+                isUpdate = true;
+            }
+            else {
+                return; // not in changeset, don't export
+            }
+        }
+        core_bentley_1.Logger.logTrace(loggerCategory, `exportFontById(${fontNumber})`);
+        const font = this.sourceDb.fontMap.getFont(fontNumber);
+        if (undefined !== font) {
+            this.handler.onExportFont(font, isUpdate);
+            return this.trackProgress();
+        }
+    }
+    /** Export the model container, contents, and sub-models from the source iModel.
+     * @note This method is called from [[exportChanges]] and [[exportAll]], so it only needs to be called directly when exporting a subset of an iModel.
+     */
+    async exportModel(modeledElementId) {
+        const model = this.sourceDb.models.getModel(modeledElementId);
+        if (model.isTemplate && !this.wantTemplateModels) {
+            return;
+        }
+        const modeledElement = this.sourceDb.elements.getElement({ id: modeledElementId, wantGeometry: this.wantGeometry, wantBRepData: this.wantGeometry });
+        core_bentley_1.Logger.logTrace(loggerCategory, `exportModel(${modeledElementId})`);
+        if (this.shouldExportElement(modeledElement)) {
+            await this.exportModelContainer(model);
+            if (this.visitElements) {
+                await this.exportModelContents(modeledElementId);
+            }
+            await this.exportSubModels(modeledElementId);
+        }
+    }
+    /** Export the model (the container only) from the source iModel. */
+    async exportModelContainer(model) {
+        let isUpdate;
+        if (undefined !== this._sourceDbChanges) { // is changeset information available?
+            if (this._sourceDbChanges.model.insertIds.has(model.id)) {
+                isUpdate = false;
+            }
+            else if (this._sourceDbChanges.model.updateIds.has(model.id)) {
+                isUpdate = true;
+            }
+            else {
+                return; // not in changeset, don't export
+            }
+        }
+        this.handler.onExportModel(model, isUpdate);
+        return this.trackProgress();
+    }
+    /** Export the model contents.
+     * @param modelId The only required parameter
+     * @param elementClassFullName Can be optionally specified if the goal is to export a subset of the model contents
+     * @param skipRootSubject Decides whether or not to export the root Subject. It is normally left undefined except for internal implementation purposes.
+     * @note This method is called from [[exportChanges]] and [[exportAll]], so it only needs to be called directly when exporting a subset of an iModel.
+     */
+    async exportModelContents(modelId, elementClassFullName = core_backend_1.Element.classFullName, skipRootSubject) {
+        if (skipRootSubject) {
+            // NOTE: IModelTransformer.processAll should skip the root Subject since it is specific to the individual iModel and is not part of the changes that need to be synchronized
+            // NOTE: IModelExporter.exportAll should not skip the root Subject since the goal is to export everything
+            (0, core_bentley_1.assert)(modelId === core_common_1.IModel.repositoryModelId); // flag is only relevant when processing the RepositoryModel
+        }
+        if (!this.visitElements) {
+            core_bentley_1.Logger.logTrace(loggerCategory, `visitElements=false, skipping exportModelContents(${modelId})`);
+            return;
+        }
+        if (undefined !== this._sourceDbChanges) { // is changeset information available?
+            if (!this._sourceDbChanges.model.insertIds.has(modelId) && !this._sourceDbChanges.model.updateIds.has(modelId)) {
+                return; // this optimization assumes that the Model changes (LastMod) any time an Element in the Model changes
+            }
+        }
+        core_bentley_1.Logger.logTrace(loggerCategory, `exportModelContents(${modelId})`);
+        let sql;
+        if (skipRootSubject) {
+            sql = `SELECT ECInstanceId FROM ${elementClassFullName} WHERE Parent.Id IS NULL AND Model.Id=:modelId AND ECInstanceId!=:rootSubjectId ORDER BY ECInstanceId`;
+        }
+        else {
+            sql = `SELECT ECInstanceId FROM ${elementClassFullName} WHERE Parent.Id IS NULL AND Model.Id=:modelId ORDER BY ECInstanceId`;
+        }
+        await this.sourceDb.withPreparedStatement(sql, async (statement) => {
+            statement.bindId("modelId", modelId);
+            if (skipRootSubject) {
+                statement.bindId("rootSubjectId", core_common_1.IModel.rootSubjectId);
+            }
+            while (core_bentley_1.DbResult.BE_SQLITE_ROW === statement.step()) {
+                await this.exportElement(statement.getValue(0).getId());
+                await this._yieldManager.allowYield();
+            }
+        });
+    }
+    /** Export the sub-models directly below the specified model.
+     * @note This method is called from [[exportChanges]] and [[exportAll]], so it only needs to be called directly when exporting a subset of an iModel.
+     */
+    async exportSubModels(parentModelId) {
+        core_bentley_1.Logger.logTrace(loggerCategory, `exportSubModels(${parentModelId})`);
+        const definitionModelIds = [];
+        const otherModelIds = [];
+        const sql = `SELECT ECInstanceId FROM ${core_backend_1.Model.classFullName} WHERE ParentModel.Id=:parentModelId ORDER BY ECInstanceId`;
+        this.sourceDb.withPreparedStatement(sql, (statement) => {
+            statement.bindId("parentModelId", parentModelId);
+            while (core_bentley_1.DbResult.BE_SQLITE_ROW === statement.step()) {
+                const modelId = statement.getValue(0).getId();
+                const model = this.sourceDb.models.getModel(modelId);
+                if (model instanceof core_backend_1.DefinitionModel) {
+                    definitionModelIds.push(modelId);
+                }
+                else {
+                    otherModelIds.push(modelId);
+                }
+            }
+        });
+        // export DefinitionModels before other types of Models
+        for (const definitionModelId of definitionModelIds) {
+            await this.exportModel(definitionModelId);
+        }
+        for (const otherModelId of otherModelIds) {
+            await this.exportModel(otherModelId);
+        }
+    }
+    /** Returns true if the specified element should be exported.
+     * This considers the standard IModelExporter exclusion rules plus calls [IModelExportHandler.shouldExportElement]($transformer) for any custom exclusion rules.
+     * @note This method is called from within [[exportChanges]] and [[exportAll]], so usually does not need to be called directly.
+     */
+    shouldExportElement(element) {
+        if (this._excludedElementIds.has(element.id)) {
+            core_bentley_1.Logger.logInfo(loggerCategory, `Excluded element ${element.id} by Id`);
+            return false;
+        }
+        if (element instanceof core_backend_1.GeometricElement) {
+            if (this._excludedElementCategoryIds.has(element.category)) {
+                core_bentley_1.Logger.logInfo(loggerCategory, `Excluded element ${element.id} by Category`);
+                return false;
+            }
+        }
+        if (!this.wantTemplateModels && (element instanceof core_backend_1.RecipeDefinitionElement)) {
+            core_bentley_1.Logger.logInfo(loggerCategory, `Excluded RecipeDefinitionElement ${element.id} because wantTemplate=false`);
+            return false;
+        }
+        for (const excludedElementClass of this._excludedElementClasses) {
+            if (element instanceof excludedElementClass) {
+                core_bentley_1.Logger.logInfo(loggerCategory, `Excluded element ${element.id} by class: ${excludedElementClass.classFullName}`);
+                return false;
+            }
+        }
+        // element has passed standard exclusion rules, now give handler a chance to accept/reject
+        return this.handler.shouldExportElement(element);
+    }
+    /** Export the specified element, its child elements (if applicable), and any owned ElementAspects.
+     * @note This method is called from [[exportChanges]] and [[exportAll]], so it only needs to be called directly when exporting a subset of an iModel.
+     */
+    async exportElement(elementId) {
+        if (!this.visitElements) {
+            core_bentley_1.Logger.logTrace(loggerCategory, `visitElements=false, skipping exportElement(${elementId})`);
+            return;
+        }
+        let isUpdate;
+        if (undefined !== this._sourceDbChanges) { // is changeset information available?
+            if (this._sourceDbChanges.element.insertIds.has(elementId)) {
+                isUpdate = false;
+            }
+            else if (this._sourceDbChanges.element.updateIds.has(elementId)) {
+                isUpdate = true;
+            }
+            else {
+                // NOTE: This optimization assumes that the Element will change (LastMod) if an owned ElementAspect changes
+                // NOTE: However, child elements may have changed without the parent changing
+                return this.exportChildElements(elementId);
+            }
+        }
+        const element = this.sourceDb.elements.getElement({ id: elementId, wantGeometry: this.wantGeometry, wantBRepData: this.wantGeometry });
+        core_bentley_1.Logger.logTrace(loggerCategory, `exportElement(${element.id}, "${element.getDisplayLabel()}")${this.getChangeOpSuffix(isUpdate)}`);
+        // the order and `await`ing of calls beyond here is depended upon by the IModelTransformer for a current bug workaround
+        if (this.shouldExportElement(element)) {
+            await this.handler.preExportElement(element);
+            this.handler.onExportElement(element, isUpdate);
+            await this.trackProgress();
+            await this.exportElementAspects(elementId);
+            return this.exportChildElements(elementId);
+        }
+    }
+    /** Export the child elements of the specified element from the source iModel.
+     * @note This method is called from [[exportChanges]] and [[exportAll]], so it only needs to be called directly when exporting a subset of an iModel.
+     */
+    async exportChildElements(elementId) {
+        if (!this.visitElements) {
+            core_bentley_1.Logger.logTrace(loggerCategory, `visitElements=false, skipping exportChildElements(${elementId})`);
+            return;
+        }
+        const childElementIds = this.sourceDb.elements.queryChildren(elementId);
+        if (childElementIds.length > 0) {
+            core_bentley_1.Logger.logTrace(loggerCategory, `exportChildElements(${elementId})`);
+            for (const childElementId of childElementIds) {
+                await this.exportElement(childElementId);
+            }
+        }
+    }
+    /** Returns `true` if the specified ElementAspect should be exported or `false` if if should be excluded. */
+    shouldExportElementAspect(aspect) {
+        for (const excludedElementAspectClass of this._excludedElementAspectClasses) {
+            if (aspect instanceof excludedElementAspectClass) {
+                core_bentley_1.Logger.logInfo(loggerCategory, `Excluded ElementAspect by class: ${aspect.classFullName}`);
+                return false;
+            }
+        }
+        // ElementAspect has passed standard exclusion rules, now give handler a chance to accept/reject
+        return this.handler.shouldExportElementAspect(aspect);
+    }
+    /** Export ElementAspects from the specified element from the source iModel. */
+    async exportElementAspects(elementId) {
+        const _uniqueAspects = await Promise.all(this.sourceDb.elements
+            ._queryAspects(elementId, core_backend_1.ElementUniqueAspect.classFullName, this._excludedElementAspectClassFullNames)
+            .filter((a) => this.shouldExportElementAspect(a))
+            .map(async (uniqueAspect) => {
+            var _a, _b, _c, _d;
+            const isInsertChange = (_b = (_a = this._sourceDbChanges) === null || _a === void 0 ? void 0 : _a.aspect.insertIds.has(uniqueAspect.id)) !== null && _b !== void 0 ? _b : false;
+            const isUpdateChange = (_d = (_c = this._sourceDbChanges) === null || _c === void 0 ? void 0 : _c.aspect.updateIds.has(uniqueAspect.id)) !== null && _d !== void 0 ? _d : false;
+            const doExport = this._sourceDbChanges === undefined || isInsertChange || isUpdateChange;
+            if (doExport) {
+                const isKnownUpdate = this._sourceDbChanges ? isUpdateChange : undefined;
+                this.handler.onExportElementUniqueAspect(uniqueAspect, isKnownUpdate);
+                await this.trackProgress();
+            }
+        }));
+        const multiAspects = this.sourceDb.elements
+            ._queryAspects(elementId, core_backend_1.ElementMultiAspect.classFullName, this._excludedElementAspectClassFullNames)
+            .filter((a) => this.shouldExportElementAspect(a));
+        if (multiAspects.length > 0) {
+            this.handler.onExportElementMultiAspects(multiAspects);
+            return this.trackProgress();
+        }
+    }
+    /** Exports all relationships that subclass from the specified base class.
+     * @note This method is called from [[exportChanges]] and [[exportAll]], so it only needs to be called directly when exporting a subset of an iModel.
+     */
+    async exportRelationships(baseRelClassFullName) {
+        if (!this.visitRelationships) {
+            core_bentley_1.Logger.logTrace(loggerCategory, `visitRelationships=false, skipping exportRelationships()`);
+            return;
+        }
+        core_bentley_1.Logger.logTrace(loggerCategory, `exportRelationships(${baseRelClassFullName})`);
+        const sql = `SELECT ECInstanceId FROM ${baseRelClassFullName}`;
+        await this.sourceDb.withPreparedStatement(sql, async (statement) => {
+            while (core_bentley_1.DbResult.BE_SQLITE_ROW === statement.step()) {
+                const relInstanceId = statement.getValue(0).getId();
+                const relProps = this.sourceDb.relationships.getInstanceProps(baseRelClassFullName, relInstanceId);
+                await this.exportRelationship(relProps.classFullName, relInstanceId); // must call exportRelationship using the actual classFullName, not baseRelClassFullName
+                await this._yieldManager.allowYield();
+            }
+        });
+    }
+    /** Export a relationship from the source iModel. */
+    async exportRelationship(relClassFullName, relInstanceId) {
+        if (!this.visitRelationships) {
+            core_bentley_1.Logger.logTrace(loggerCategory, `visitRelationships=false, skipping exportRelationship(${relClassFullName}, ${relInstanceId})`);
+            return;
+        }
+        let isUpdate;
+        if (undefined !== this._sourceDbChanges) { // is changeset information available?
+            if (this._sourceDbChanges.relationship.insertIds.has(relInstanceId)) {
+                isUpdate = false;
+            }
+            else if (this._sourceDbChanges.relationship.updateIds.has(relInstanceId)) {
+                isUpdate = true;
+            }
+            else {
+                return; // not in changeset, don't export
+            }
+        }
+        // passed changeset test, now apply standard exclusion rules
+        core_bentley_1.Logger.logTrace(loggerCategory, `exportRelationship(${relClassFullName}, ${relInstanceId})`);
+        const relationship = this.sourceDb.relationships.getInstance(relClassFullName, relInstanceId);
+        for (const excludedRelationshipClass of this._excludedRelationshipClasses) {
+            if (relationship instanceof excludedRelationshipClass) {
+                core_bentley_1.Logger.logInfo(loggerCategory, `Excluded relationship by class: ${excludedRelationshipClass.classFullName}`);
+                return;
+            }
+        }
+        // relationship has passed standard exclusion rules, now give handler a chance to accept/reject export
+        if (this.handler.shouldExportRelationship(relationship)) {
+            this.handler.onExportRelationship(relationship, isUpdate);
+            await this.trackProgress();
+        }
+    }
+    /** Tracks incremental progress */
+    async trackProgress() {
+        this._progressCounter++;
+        if (0 === (this._progressCounter % this.progressInterval)) {
+            return this.handler.onProgress();
+        }
+    }
+    /**
+     * You may override this to store arbitrary json state in a exporter state dump, useful for some resumptions
+     * @see [[IModelTransformer.saveStateToFile]]
+     */
+    getAdditionalStateJson() {
+        return {};
+    }
+    /**
+     * You may override this to load arbitrary json state in a transformer state dump, useful for some resumptions
+     * @see [[IModelTransformer.loadStateFromFile]]
+     */
+    loadAdditionalStateJson(_additionalState) { }
+    /**
+     * Reload our state from a JSON object
+     * Intended for [[IModelTransformer.resumeTransformation]]
+     * @internal
+     * You can load custom json from the exporter save state for custom exporters by overriding [[IModelExporter.loadAdditionalStateJson]]
+     */
+    loadStateFromJson(state) {
+        if (state.exporterClass !== this.constructor.name)
+            throw Error("resuming from a differently named exporter class, it is not necessarily valid to resume with a different exporter class");
+        this.wantGeometry = state.wantGeometry;
+        this.wantTemplateModels = state.wantTemplateModels;
+        this.wantSystemSchemas = state.wantSystemSchemas;
+        this.visitElements = state.visitElements;
+        this.visitRelationships = state.visitRelationships;
+        this._excludedCodeSpecNames = new Set(state.excludedCodeSpecNames);
+        this._excludedElementIds = core_bentley_1.CompressedId64Set.decompressSet(state.excludedElementIds),
+            this._excludedElementCategoryIds = core_bentley_1.CompressedId64Set.decompressSet(state.excludedElementCategoryIds),
+            this._excludedElementClasses = new Set(state.excludedElementClassNames.map((c) => this.sourceDb.getJsClass(c)));
+        this._excludedElementAspectClassFullNames = new Set(state.excludedElementAspectClassFullNames);
+        this._excludedElementAspectClasses = new Set(state.excludedElementAspectClassFullNames.map((c) => this.sourceDb.getJsClass(c)));
+        this._excludedRelationshipClasses = new Set(state.excludedRelationshipClassNames.map((c) => this.sourceDb.getJsClass(c)));
+        this.loadAdditionalStateJson(state.additionalState);
+    }
+    /**
+     * Serialize state to a JSON object
+     * Intended for [[IModelTransformer.resumeTransformation]]
+     * @internal
+     * You can add custom json to the exporter save state for custom exporters by overriding [[IModelExporter.getAdditionalStateJson]]
+     */
+    saveStateToJson() {
+        return {
+            exporterClass: this.constructor.name,
+            wantGeometry: this.wantGeometry,
+            wantTemplateModels: this.wantTemplateModels,
+            wantSystemSchemas: this.wantSystemSchemas,
+            visitElements: this.visitElements,
+            visitRelationships: this.visitRelationships,
+            excludedCodeSpecNames: [...this._excludedCodeSpecNames],
+            excludedElementIds: core_bentley_1.CompressedId64Set.compressSet(this._excludedElementIds),
+            excludedElementCategoryIds: core_bentley_1.CompressedId64Set.compressSet(this._excludedElementCategoryIds),
+            excludedElementClassNames: Array.from(this._excludedElementClasses, (cls) => cls.classFullName),
+            excludedElementAspectClassFullNames: [...this._excludedElementAspectClassFullNames],
+            excludedRelationshipClassNames: Array.from(this._excludedRelationshipClasses, (cls) => cls.classFullName),
+            additionalState: this.getAdditionalStateJson(),
+        };
+    }
+}
+exports.IModelExporter = IModelExporter;
+/** Class for holding change information.
+ * @beta
+*/
+class ChangedInstanceOps {
+    constructor() {
+        this.insertIds = new Set();
+        this.updateIds = new Set();
+        this.deleteIds = new Set();
+    }
+    /** Initializes the object from IModelJsNative.ChangedInstanceOpsProps. */
+    addFromJson(val) {
+        if (undefined !== val) {
+            if ((undefined !== val.insert) && (Array.isArray(val.insert)))
+                val.insert.forEach((id) => this.insertIds.add(id));
+            if ((undefined !== val.update) && (Array.isArray(val.update)))
+                val.update.forEach((id) => this.updateIds.add(id));
+            if ((undefined !== val.delete) && (Array.isArray(val.delete)))
+                val.delete.forEach((id) => this.deleteIds.add(id));
+        }
+    }
+}
+exports.ChangedInstanceOps = ChangedInstanceOps;
+/**
+ * Class for discovering modified elements between 2 versions of an iModel.
+ * @beta
+ */
+class ChangedInstanceIds {
+    constructor() {
+        this.codeSpec = new ChangedInstanceOps();
+        this.model = new ChangedInstanceOps();
+        this.element = new ChangedInstanceOps();
+        this.aspect = new ChangedInstanceOps();
+        this.relationship = new ChangedInstanceOps();
+        this.font = new ChangedInstanceOps();
+    }
+    /**
+     * Initializes a new ChangedInstanceIds object with information taken from a range of changesets.
+     * @param accessToken Access token.
+     * @param iModel IModel briefcase whose changesets will be queried.
+     * @param firstChangesetId Changeset id.
+     * @note Modified element information will be taken from a range of changesets. First changeset in a range will be the 'firstChangesetId', the last will be whichever changeset the 'iModel' briefcase is currently opened on.
+     */
+    static async initialize(accessToken, iModel, firstChangesetId) {
+        const iModelId = iModel.iModelId;
+        const first = (await core_backend_1.IModelHost.hubAccess.queryChangeset({ iModelId, changeset: { id: firstChangesetId }, accessToken })).index;
+        const end = (await core_backend_1.IModelHost.hubAccess.queryChangeset({ iModelId, changeset: { id: iModel.changeset.id }, accessToken })).index;
+        const changesets = await core_backend_1.IModelHost.hubAccess.downloadChangesets({ accessToken, iModelId, range: { first, end }, targetDir: core_backend_1.BriefcaseManager.getChangeSetsPath(iModelId) });
+        const changedInstanceIds = new ChangedInstanceIds();
+        const changesetFiles = changesets.map((c) => c.pathname);
+        const statusOrResult = iModel.nativeDb.extractChangedInstanceIdsFromChangeSets(changesetFiles);
+        if (statusOrResult.error) {
+            throw new core_common_1.IModelError(statusOrResult.error.status, "Error processing changeset");
+        }
+        const result = statusOrResult.result;
+        (0, core_bentley_1.assert)(result !== undefined);
+        changedInstanceIds.codeSpec.addFromJson(result.codeSpec);
+        changedInstanceIds.model.addFromJson(result.model);
+        changedInstanceIds.element.addFromJson(result.element);
+        changedInstanceIds.aspect.addFromJson(result.aspect);
+        changedInstanceIds.relationship.addFromJson(result.relationship);
+        changedInstanceIds.font.addFromJson(result.font);
+        return changedInstanceIds;
+    }
+}
+exports.ChangedInstanceIds = ChangedInstanceIds;
+//# sourceMappingURL=IModelExporter.js.map