orcaq 1.0.20

package/.output/server/node_modules/typeorm/query-builder/RelationLoader.js

@@ -0,0 +1,283 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationLoader = void 0;
+const FindOptionsUtils_1 = require("../find-options/FindOptionsUtils");
+/**
+ * Wraps entities and creates getters/setters for their relations
+ * to be able to lazily load relations when accessing these relations.
+ */
+class RelationLoader {
+    // -------------------------------------------------------------------------
+    // Constructor
+    // -------------------------------------------------------------------------
+    constructor(connection) {
+        this.connection = connection;
+    }
+    // -------------------------------------------------------------------------
+    // Public Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Loads relation data for the given entity and its relation.
+     */
+    load(relation, entityOrEntities, queryRunner, queryBuilder) {
+        // todo: check all places where it uses non array
+        if (queryRunner && queryRunner.isReleased)
+            queryRunner = undefined; // get new one if already closed
+        if (relation.isManyToOne || relation.isOneToOneOwner) {
+            return this.loadManyToOneOrOneToOneOwner(relation, entityOrEntities, queryRunner, queryBuilder);
+        }
+        else if (relation.isOneToMany || relation.isOneToOneNotOwner) {
+            return this.loadOneToManyOrOneToOneNotOwner(relation, entityOrEntities, queryRunner, queryBuilder);
+        }
+        else if (relation.isManyToManyOwner) {
+            return this.loadManyToManyOwner(relation, entityOrEntities, queryRunner, queryBuilder);
+        }
+        else {
+            // many-to-many non owner
+            return this.loadManyToManyNotOwner(relation, entityOrEntities, queryRunner, queryBuilder);
+        }
+    }
+    /**
+     * Loads data for many-to-one and one-to-one owner relations.
+     *
+     * (ow) post.category<=>category.post
+     * loaded: category from post
+     * example: SELECT category.id AS category_id, category.name AS category_name FROM category category
+     *              INNER JOIN post Post ON Post.category=category.id WHERE Post.id=1
+     */
+    loadManyToOneOrOneToOneOwner(relation, entityOrEntities, queryRunner, queryBuilder) {
+        const entities = Array.isArray(entityOrEntities)
+            ? entityOrEntities
+            : [entityOrEntities];
+        const joinAliasName = relation.entityMetadata.name;
+        const qb = queryBuilder
+            ? queryBuilder
+            : this.connection
+                .createQueryBuilder(queryRunner)
+                .select(relation.propertyName) // category
+                .from(relation.type, relation.propertyName);
+        const mainAlias = qb.expressionMap.mainAlias.name;
+        const columns = relation.entityMetadata.primaryColumns;
+        const joinColumns = relation.isOwning
+            ? relation.joinColumns
+            : relation.inverseRelation.joinColumns;
+        const conditions = joinColumns
+            .map((joinColumn) => {
+            return `${relation.entityMetadata.name}.${joinColumn.propertyName} = ${mainAlias}.${joinColumn.referencedColumn.propertyName}`;
+        })
+            .join(" AND ");
+        qb.innerJoin(relation.entityMetadata.target, joinAliasName, conditions);
+        if (columns.length === 1) {
+            qb.where(`${joinAliasName}.${columns[0].propertyPath} IN (:...${joinAliasName + "_" + columns[0].propertyName})`);
+            qb.setParameter(joinAliasName + "_" + columns[0].propertyName, entities.map((entity) => columns[0].getEntityValue(entity, true)));
+        }
+        else {
+            const condition = entities
+                .map((entity, entityIndex) => {
+                return columns
+                    .map((column, columnIndex) => {
+                    const paramName = joinAliasName +
+                        "_entity_" +
+                        entityIndex +
+                        "_" +
+                        columnIndex;
+                    qb.setParameter(paramName, column.getEntityValue(entity, true));
+                    return (joinAliasName +
+                        "." +
+                        column.propertyPath +
+                        " = :" +
+                        paramName);
+                })
+                    .join(" AND ");
+            })
+                .map((condition) => "(" + condition + ")")
+                .join(" OR ");
+            qb.where(condition);
+        }
+        FindOptionsUtils_1.FindOptionsUtils.joinEagerRelations(qb, qb.alias, qb.expressionMap.mainAlias.metadata);
+        return qb.getMany();
+        // return qb.getOne(); todo: fix all usages
+    }
+    /**
+     * Loads data for one-to-many and one-to-one not owner relations.
+     *
+     * SELECT post
+     * FROM post post
+     * WHERE post.[joinColumn.name] = entity[joinColumn.referencedColumn]
+     */
+    loadOneToManyOrOneToOneNotOwner(relation, entityOrEntities, queryRunner, queryBuilder) {
+        const entities = Array.isArray(entityOrEntities)
+            ? entityOrEntities
+            : [entityOrEntities];
+        const columns = relation.inverseRelation.joinColumns;
+        const qb = queryBuilder
+            ? queryBuilder
+            : this.connection
+                .createQueryBuilder(queryRunner)
+                .select(relation.propertyName)
+                .from(relation.inverseRelation.entityMetadata.target, relation.propertyName);
+        const aliasName = qb.expressionMap.mainAlias.name;
+        if (columns.length === 1) {
+            qb.where(`${aliasName}.${columns[0].propertyPath} IN (:...${aliasName + "_" + columns[0].propertyName})`);
+            qb.setParameter(aliasName + "_" + columns[0].propertyName, entities.map((entity) => columns[0].referencedColumn.getEntityValue(entity, true)));
+        }
+        else {
+            const condition = entities
+                .map((entity, entityIndex) => {
+                return columns
+                    .map((column, columnIndex) => {
+                    const paramName = aliasName +
+                        "_entity_" +
+                        entityIndex +
+                        "_" +
+                        columnIndex;
+                    qb.setParameter(paramName, column.referencedColumn.getEntityValue(entity, true));
+                    return (aliasName +
+                        "." +
+                        column.propertyPath +
+                        " = :" +
+                        paramName);
+                })
+                    .join(" AND ");
+            })
+                .map((condition) => "(" + condition + ")")
+                .join(" OR ");
+            qb.where(condition);
+        }
+        FindOptionsUtils_1.FindOptionsUtils.joinEagerRelations(qb, qb.alias, qb.expressionMap.mainAlias.metadata);
+        return qb.getMany();
+        // return relation.isOneToMany ? qb.getMany() : qb.getOne(); todo: fix all usages
+    }
+    /**
+     * Loads data for many-to-many owner relations.
+     *
+     * SELECT category
+     * FROM category category
+     * INNER JOIN post_categories post_categories
+     * ON post_categories.postId = :postId
+     * AND post_categories.categoryId = category.id
+     */
+    loadManyToManyOwner(relation, entityOrEntities, queryRunner, queryBuilder) {
+        const entities = Array.isArray(entityOrEntities)
+            ? entityOrEntities
+            : [entityOrEntities];
+        const parameters = relation.joinColumns.reduce((parameters, joinColumn) => {
+            parameters[joinColumn.propertyName] = entities.map((entity) => joinColumn.referencedColumn.getEntityValue(entity, true));
+            return parameters;
+        }, {});
+        const qb = queryBuilder
+            ? queryBuilder
+            : this.connection
+                .createQueryBuilder(queryRunner)
+                .select(relation.propertyName)
+                .from(relation.type, relation.propertyName);
+        const mainAlias = qb.expressionMap.mainAlias.name;
+        const joinAlias = relation.junctionEntityMetadata.tableName;
+        const joinColumnConditions = relation.joinColumns.map((joinColumn) => {
+            return `${joinAlias}.${joinColumn.propertyName} IN (:...${joinColumn.propertyName})`;
+        });
+        const inverseJoinColumnConditions = relation.inverseJoinColumns.map((inverseJoinColumn) => {
+            return `${joinAlias}.${inverseJoinColumn.propertyName}=${mainAlias}.${inverseJoinColumn.referencedColumn.propertyName}`;
+        });
+        qb.innerJoin(joinAlias, joinAlias, [...joinColumnConditions, ...inverseJoinColumnConditions].join(" AND ")).setParameters(parameters);
+        FindOptionsUtils_1.FindOptionsUtils.joinEagerRelations(qb, qb.alias, qb.expressionMap.mainAlias.metadata);
+        return qb.getMany();
+    }
+    /**
+     * Loads data for many-to-many not owner relations.
+     *
+     * SELECT post
+     * FROM post post
+     * INNER JOIN post_categories post_categories
+     * ON post_categories.postId = post.id
+     * AND post_categories.categoryId = post_categories.categoryId
+     */
+    loadManyToManyNotOwner(relation, entityOrEntities, queryRunner, queryBuilder) {
+        const entities = Array.isArray(entityOrEntities)
+            ? entityOrEntities
+            : [entityOrEntities];
+        const qb = queryBuilder
+            ? queryBuilder
+            : this.connection
+                .createQueryBuilder(queryRunner)
+                .select(relation.propertyName)
+                .from(relation.type, relation.propertyName);
+        const mainAlias = qb.expressionMap.mainAlias.name;
+        const joinAlias = relation.junctionEntityMetadata.tableName;
+        const joinColumnConditions = relation.inverseRelation.joinColumns.map((joinColumn) => {
+            return `${joinAlias}.${joinColumn.propertyName} = ${mainAlias}.${joinColumn.referencedColumn.propertyName}`;
+        });
+        const inverseJoinColumnConditions = relation.inverseRelation.inverseJoinColumns.map((inverseJoinColumn) => {
+            return `${joinAlias}.${inverseJoinColumn.propertyName} IN (:...${inverseJoinColumn.propertyName})`;
+        });
+        const parameters = relation.inverseRelation.inverseJoinColumns.reduce((parameters, joinColumn) => {
+            parameters[joinColumn.propertyName] = entities.map((entity) => joinColumn.referencedColumn.getEntityValue(entity, true));
+            return parameters;
+        }, {});
+        qb.innerJoin(joinAlias, joinAlias, [...joinColumnConditions, ...inverseJoinColumnConditions].join(" AND ")).setParameters(parameters);
+        FindOptionsUtils_1.FindOptionsUtils.joinEagerRelations(qb, qb.alias, qb.expressionMap.mainAlias.metadata);
+        return qb.getMany();
+    }
+    /**
+     * Wraps given entity and creates getters/setters for its given relation
+     * to be able to lazily load data when accessing this relation.
+     */
+    enableLazyLoad(relation, entity, queryRunner) {
+        const relationLoader = this;
+        const dataIndex = "__" + relation.propertyName + "__"; // in what property of the entity loaded data will be stored
+        const promiseIndex = "__promise_" + relation.propertyName + "__"; // in what property of the entity loading promise will be stored
+        const resolveIndex = "__has_" + relation.propertyName + "__"; // indicates if relation data already was loaded or not, we need this flag if loaded data is empty
+        const setData = (entity, value) => {
+            entity[dataIndex] = value;
+            entity[resolveIndex] = true;
+            delete entity[promiseIndex];
+            return value;
+        };
+        const setPromise = (entity, value) => {
+            delete entity[resolveIndex];
+            delete entity[dataIndex];
+            entity[promiseIndex] = value;
+            value.then(
+            // ensure different value is not assigned yet
+            (result) => entity[promiseIndex] === value
+                ? setData(entity, result)
+                : result);
+            return value;
+        };
+        Object.defineProperty(entity, relation.propertyName, {
+            get: function () {
+                if (this[resolveIndex] === true ||
+                    this[dataIndex] !== undefined)
+                    // if related data already was loaded then simply return it
+                    return Promise.resolve(this[dataIndex]);
+                if (this[promiseIndex])
+                    // if related data is loading then return a promise relationLoader loads it
+                    return this[promiseIndex];
+                // nothing is loaded yet, load relation data and save it in the model once they are loaded
+                const loader = relationLoader
+                    .load(relation, this, queryRunner)
+                    .then((result) => relation.isOneToOne || relation.isManyToOne
+                    ? result.length === 0
+                        ? null
+                        : result[0]
+                    : result);
+                return setPromise(this, loader);
+            },
+            set: function (value) {
+                if (value instanceof Promise) {
+                    // if set data is a promise then wait for its resolve and save in the object
+                    setPromise(this, value);
+                }
+                else {
+                    // if its direct data set (non promise, probably not safe-typed)
+                    setData(this, value);
+                }
+            },
+            configurable: true,
+            enumerable: false,
+        });
+    }
+}
+exports.RelationLoader = RelationLoader;
+
+//# sourceMappingURL=RelationLoader.js.map

package/.output/server/node_modules/typeorm/query-builder/RelationQueryBuilder.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationQueryBuilder = void 0;
+const QueryBuilder_1 = require("./QueryBuilder");
+const RelationUpdater_1 = require("./RelationUpdater");
+const RelationRemover_1 = require("./RelationRemover");
+const error_1 = require("../error");
+const ObjectUtils_1 = require("../util/ObjectUtils");
+/**
+ * Allows to work with entity relations and perform specific operations with those relations.
+ *
+ * todo: add transactions everywhere
+ */
+class RelationQueryBuilder extends QueryBuilder_1.QueryBuilder {
+    constructor() {
+        super(...arguments);
+        this["@instanceof"] = Symbol.for("RelationQueryBuilder");
+    }
+    // -------------------------------------------------------------------------
+    // Public Implemented Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Gets generated SQL query without parameters being replaced.
+     */
+    getQuery() {
+        return "";
+    }
+    // -------------------------------------------------------------------------
+    // Public Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Sets entity (target) which relations will be updated.
+     */
+    of(entity) {
+        this.expressionMap.of = entity;
+        return this;
+    }
+    /**
+     * Sets entity relation's value.
+     * Value can be entity, entity id or entity id map (if entity has composite ids).
+     * Works only for many-to-one and one-to-one relations.
+     * For many-to-many and one-to-many relations use #add and #remove methods instead.
+     */
+    async set(value) {
+        const relation = this.expressionMap.relationMetadata;
+        if (!this.expressionMap.of)
+            // todo: move this check before relation query builder creation?
+            throw new error_1.TypeORMError(`Entity whose relation needs to be set is not set. Use .of method to define whose relation you want to set.`);
+        if (relation.isManyToMany || relation.isOneToMany)
+            throw new error_1.TypeORMError(`Set operation is only supported for many-to-one and one-to-one relations. ` +
+                `However given "${relation.propertyPath}" has ${relation.relationType} relation. ` +
+                `Use .add() method instead.`);
+        // if there are multiple join columns then user must send id map as "value" argument. check if he really did it
+        if (relation.joinColumns &&
+            relation.joinColumns.length > 1 &&
+            (!ObjectUtils_1.ObjectUtils.isObject(value) ||
+                Object.keys(value).length < relation.joinColumns.length))
+            throw new error_1.TypeORMError(`Value to be set into the relation must be a map of relation ids, for example: .set({ firstName: "...", lastName: "..." })`);
+        const updater = new RelationUpdater_1.RelationUpdater(this, this.expressionMap);
+        return updater.update(value);
+    }
+    /**
+     * Adds (binds) given value to entity relation.
+     * Value can be entity, entity id or entity id map (if entity has composite ids).
+     * Value also can be array of entities, array of entity ids or array of entity id maps (if entity has composite ids).
+     * Works only for many-to-many and one-to-many relations.
+     * For many-to-one and one-to-one use #set method instead.
+     */
+    async add(value) {
+        if (Array.isArray(value) && value.length === 0)
+            return;
+        const relation = this.expressionMap.relationMetadata;
+        if (!this.expressionMap.of)
+            // todo: move this check before relation query builder creation?
+            throw new error_1.TypeORMError(`Entity whose relation needs to be set is not set. Use .of method to define whose relation you want to set.`);
+        if (relation.isManyToOne || relation.isOneToOne)
+            throw new error_1.TypeORMError(`Add operation is only supported for many-to-many and one-to-many relations. ` +
+                `However given "${relation.propertyPath}" has ${relation.relationType} relation. ` +
+                `Use .set() method instead.`);
+        // if there are multiple join columns then user must send id map as "value" argument. check if he really did it
+        if (relation.joinColumns &&
+            relation.joinColumns.length > 1 &&
+            (!ObjectUtils_1.ObjectUtils.isObject(value) ||
+                Object.keys(value).length < relation.joinColumns.length))
+            throw new error_1.TypeORMError(`Value to be set into the relation must be a map of relation ids, for example: .set({ firstName: "...", lastName: "..." })`);
+        const updater = new RelationUpdater_1.RelationUpdater(this, this.expressionMap);
+        return updater.update(value);
+    }
+    /**
+     * Removes (unbinds) given value from entity relation.
+     * Value can be entity, entity id or entity id map (if entity has composite ids).
+     * Value also can be array of entities, array of entity ids or array of entity id maps (if entity has composite ids).
+     * Works only for many-to-many and one-to-many relations.
+     * For many-to-one and one-to-one use #set method instead.
+     */
+    async remove(value) {
+        if (Array.isArray(value) && value.length === 0)
+            return;
+        const relation = this.expressionMap.relationMetadata;
+        if (!this.expressionMap.of)
+            // todo: move this check before relation query builder creation?
+            throw new error_1.TypeORMError(`Entity whose relation needs to be set is not set. Use .of method to define whose relation you want to set.`);
+        if (relation.isManyToOne || relation.isOneToOne)
+            throw new error_1.TypeORMError(`Add operation is only supported for many-to-many and one-to-many relations. ` +
+                `However given "${relation.propertyPath}" has ${relation.relationType} relation. ` +
+                `Use .set(null) method instead.`);
+        const remover = new RelationRemover_1.RelationRemover(this, this.expressionMap);
+        return remover.remove(value);
+    }
+    /**
+     * Adds (binds) and removes (unbinds) given values to/from entity relation.
+     * Value can be entity, entity id or entity id map (if entity has composite ids).
+     * Value also can be array of entities, array of entity ids or array of entity id maps (if entity has composite ids).
+     * Works only for many-to-many and one-to-many relations.
+     * For many-to-one and one-to-one use #set method instead.
+     */
+    async addAndRemove(added, removed) {
+        await this.remove(removed);
+        await this.add(added);
+    }
+    /**
+     * Gets entity's relation id.
+    async getId(): Promise<any> {
+
+    }*/
+    /**
+     * Gets entity's relation ids.
+    async getIds(): Promise<any[]> {
+        return [];
+    }*/
+    /**
+     * Loads a single entity (relational) from the relation.
+     * You can also provide id of relational entity to filter by.
+     */
+    async loadOne() {
+        return this.loadMany().then((results) => results[0]);
+    }
+    /**
+     * Loads many entities (relational) from the relation.
+     * You can also provide ids of relational entities to filter by.
+     */
+    async loadMany() {
+        let of = this.expressionMap.of;
+        if (!ObjectUtils_1.ObjectUtils.isObject(of)) {
+            const metadata = this.expressionMap.mainAlias.metadata;
+            if (metadata.hasMultiplePrimaryKeys)
+                throw new error_1.TypeORMError(`Cannot load entity because only one primary key was specified, however entity contains multiple primary keys`);
+            of = metadata.primaryColumns[0].createValueMap(of);
+        }
+        return this.connection.relationLoader.load(this.expressionMap.relationMetadata, of, this.queryRunner);
+    }
+}
+exports.RelationQueryBuilder = RelationQueryBuilder;
+
+//# sourceMappingURL=RelationQueryBuilder.js.map

package/.output/server/node_modules/typeorm/query-builder/RelationRemover.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationRemover = void 0;
+const ObjectUtils_1 = require("../util/ObjectUtils");
+/**
+ * Allows to work with entity relations and perform specific operations with those relations.
+ *
+ * todo: add transactions everywhere
+ */
+class RelationRemover {
+    // -------------------------------------------------------------------------
+    // Constructor
+    // -------------------------------------------------------------------------
+    constructor(queryBuilder, expressionMap) {
+        this.queryBuilder = queryBuilder;
+        this.expressionMap = expressionMap;
+    }
+    // -------------------------------------------------------------------------
+    // Public Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Performs remove operation on a relation.
+     */
+    async remove(value) {
+        const relation = this.expressionMap.relationMetadata;
+        if (relation.isOneToMany) {
+            // if (this.expressionMap.of instanceof Array)
+            //     throw new TypeORMError(`You cannot update relations of multiple entities with the same related object. Provide a single entity into .of method.`);
+            // DELETE FROM post WHERE post.categoryId = of AND post.id = id
+            const ofs = Array.isArray(this.expressionMap.of)
+                ? this.expressionMap.of
+                : [this.expressionMap.of];
+            const values = Array.isArray(value) ? value : [value];
+            const updateSet = {};
+            relation.inverseRelation.joinColumns.forEach((column) => {
+                updateSet[column.propertyName] = null;
+            });
+            const parameters = {};
+            const conditions = [];
+            ofs.forEach((of, ofIndex) => {
+                conditions.push(...values.map((value, valueIndex) => {
+                    return [
+                        ...relation.inverseRelation.joinColumns.map((column, columnIndex) => {
+                            const parameterName = "joinColumn_" +
+                                ofIndex +
+                                "_" +
+                                valueIndex +
+                                "_" +
+                                columnIndex;
+                            parameters[parameterName] =
+                                ObjectUtils_1.ObjectUtils.isObject(of)
+                                    ? column.referencedColumn.getEntityValue(of)
+                                    : of;
+                            return `${column.propertyPath} = :${parameterName}`;
+                        }),
+                        ...relation.inverseRelation.entityMetadata.primaryColumns.map((column, columnIndex) => {
+                            const parameterName = "primaryColumn_" +
+                                valueIndex +
+                                "_" +
+                                valueIndex +
+                                "_" +
+                                columnIndex;
+                            parameters[parameterName] =
+                                ObjectUtils_1.ObjectUtils.isObject(value)
+                                    ? column.getEntityValue(value)
+                                    : value;
+                            return `${column.propertyPath} = :${parameterName}`;
+                        }),
+                    ].join(" AND ");
+                }));
+            });
+            const condition = conditions
+                .map((str) => "(" + str + ")")
+                .join(" OR ");
+            if (!condition)
+                return;
+            await this.queryBuilder
+                .createQueryBuilder()
+                .update(relation.inverseEntityMetadata.target)
+                .set(updateSet)
+                .where(condition)
+                .setParameters(parameters)
+                .execute();
+        }
+        else {
+            // many to many
+            const junctionMetadata = relation.junctionEntityMetadata;
+            const ofs = Array.isArray(this.expressionMap.of)
+                ? this.expressionMap.of
+                : [this.expressionMap.of];
+            const values = Array.isArray(value) ? value : [value];
+            const firstColumnValues = relation.isManyToManyOwner ? ofs : values;
+            const secondColumnValues = relation.isManyToManyOwner ? values : ofs;
+            const parameters = {};
+            const conditions = [];
+            firstColumnValues.forEach((firstColumnVal, firstColumnValIndex) => {
+                conditions.push(...secondColumnValues.map((secondColumnVal, secondColumnValIndex) => {
+                    return [
+                        ...junctionMetadata.ownerColumns.map((column, columnIndex) => {
+                            const parameterName = "firstValue_" +
+                                firstColumnValIndex +
+                                "_" +
+                                secondColumnValIndex +
+                                "_" +
+                                columnIndex;
+                            parameters[parameterName] =
+                                ObjectUtils_1.ObjectUtils.isObject(firstColumnVal)
+                                    ? column.referencedColumn.getEntityValue(firstColumnVal)
+                                    : firstColumnVal;
+                            return `${column.databaseName} = :${parameterName}`;
+                        }),
+                        ...junctionMetadata.inverseColumns.map((column, columnIndex) => {
+                            const parameterName = "secondValue_" +
+                                firstColumnValIndex +
+                                "_" +
+                                secondColumnValIndex +
+                                "_" +
+                                columnIndex;
+                            parameters[parameterName] =
+                                ObjectUtils_1.ObjectUtils.isObject(secondColumnVal)
+                                    ? column.referencedColumn.getEntityValue(secondColumnVal)
+                                    : secondColumnVal;
+                            return `${column.databaseName} = :${parameterName}`;
+                        }),
+                    ].join(" AND ");
+                }));
+            });
+            const condition = conditions
+                .map((str) => "(" + str + ")")
+                .join(" OR ");
+            await this.queryBuilder
+                .createQueryBuilder()
+                .delete()
+                .from(junctionMetadata.tableName)
+                .where(condition)
+                .setParameters(parameters)
+                .execute();
+        }
+    }
+}
+exports.RelationRemover = RelationRemover;
+
+//# sourceMappingURL=RelationRemover.js.map