orcaq 1.0.26 → 1.0.28

package/.output/server/node_modules/typeorm/persistence/subject-builder/OneToManySubjectBuilder.js

@@ -1,181 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OneToManySubjectBuilder = void 0;
-const Subject_1 = require("../Subject");
-const OrmUtils_1 = require("../../util/OrmUtils");
-const EntityMetadata_1 = require("../../metadata/EntityMetadata");
-/**
- * Builds operations needs to be executed for one-to-many relations of the given subjects.
- *
- * by example: post contains one-to-many relation with category in the property called "categories", e.g.
- *             @OneToMany(type => Category, category => category.post) categories: Category[]
- *             If user adds categories into the post and saves post we need to bind them.
- *             This operation requires updation of category table since its owner of the relation and contains a join column.
- *
- * note: this class shares lot of things with OneToOneInverseSideOperationBuilder, so when you change this class
- *       make sure to reflect changes there as well.
- */
-class OneToManySubjectBuilder {
-    // ---------------------------------------------------------------------
-    // Constructor
-    // ---------------------------------------------------------------------
-    constructor(subjects) {
-        this.subjects = subjects;
-    }
-    // ---------------------------------------------------------------------
-    // Public Methods
-    // ---------------------------------------------------------------------
-    /**
-     * Builds all required operations.
-     */
-    build() {
-        this.subjects.forEach((subject) => {
-            subject.metadata.oneToManyRelations.forEach((relation) => {
-                // skip relations for which persistence is disabled
-                if (relation.persistenceEnabled === false)
-                    return;
-                this.buildForSubjectRelation(subject, relation);
-            });
-        });
-    }
-    // ---------------------------------------------------------------------
-    // Protected Methods
-    // ---------------------------------------------------------------------
-    /**
-     * Builds operations for a given subject and relation.
-     *
-     * by example: subject is "post" entity we are saving here and relation is "categories" inside it here.
-     */
-    buildForSubjectRelation(subject, relation) {
-        // prepare objects (relation id maps) for the database entity
-        // by example: since subject is a post, we are expecting to get all post's categories saved in the database here,
-        //             particularly their relation ids, e.g. category ids stored in the database
-        // in most cases relatedEntityDatabaseValues will contain only the entity key properties.
-        // this is because subject.databaseEntity contains relations with loaded relation ids only.
-        // however if the entity uses the afterLoad hook to calculate any properties, the fetched "key object" might include ADDITIONAL properties.
-        // to handle such situations, we pass the data to relation.inverseEntityMetadata.getEntityIdMap to extract the key without any other properties.
-        let relatedEntityDatabaseRelationIds = [];
-        if (subject.databaseEntity) {
-            // related entities in the database can exist only if this entity (post) is saved
-            const relatedEntityDatabaseRelation = relation.getEntityValue(subject.databaseEntity);
-            if (relatedEntityDatabaseRelation) {
-                relatedEntityDatabaseRelationIds =
-                    relatedEntityDatabaseRelation.map((entity) => relation.inverseEntityMetadata.getEntityIdMap(entity));
-            }
-        }
-        // get related entities of persisted entity
-        // by example: get categories from the passed to persist post entity
-        let relatedEntities = relation.getEntityValue(subject.entity);
-        if (relatedEntities === null)
-            // we treat relations set to null as removed, so we don't skip it
-            relatedEntities = [];
-        if (relatedEntities === undefined)
-            // if relation is undefined then nothing to update
-            return;
-        // extract only relation ids from the related entities, since we only need them for comparison
-        // by example: extract from categories only relation ids (category id, or let's say category title, depend on join column options)
-        const relatedPersistedEntityRelationIds = [];
-        relatedEntities.forEach((relatedEntity) => {
-            // by example: relatedEntity is a category here
-            let relationIdMap = relation.inverseEntityMetadata.getEntityIdMap(relatedEntity); // by example: relationIdMap is category.id map here, e.g. { id: ... }
-            // try to find a subject of this related entity, maybe it was loaded or was marked for persistence
-            let relatedEntitySubject = this.subjects.find((subject) => {
-                return subject.entity === relatedEntity;
-            });
-            // if subject with entity was found take subject identifier as relation id map since it may contain extra properties resolved
-            if (relatedEntitySubject)
-                relationIdMap = relatedEntitySubject.identifier;
-            // if relationIdMap is undefined then it means user binds object which is not saved in the database yet
-            // by example: if post contains categories which does not have ids yet (because they are new)
-            //             it means they are always newly inserted and relation update operation always must be created for them
-            //             it does not make sense to perform difference operation for them for both add and remove actions
-            if (!relationIdMap) {
-                // we decided to remove this error because it brings complications when saving object with non-saved entities
-                // if (!relatedEntitySubject)
-                //     throw new TypeORMError(`One-to-many relation "${relation.entityMetadata.name}.${relation.propertyPath}" contains ` +
-                //         `entities which do not exist in the database yet, thus they cannot be bind in the database. ` +
-                //         `Please setup cascade insertion or save entities before binding it.`);
-                if (!relatedEntitySubject)
-                    return;
-                // okay, so related subject exist and its marked for insertion, then add a new change map
-                // by example: this will tell category to insert into its post relation our post we are working with
-                //             relatedEntitySubject is newly inserted CategorySubject
-                //             relation.inverseRelation is ManyToOne relation inside Category
-                //             subject is Post needs to be inserted into Category
-                relatedEntitySubject.changeMaps.push({
-                    relation: relation.inverseRelation,
-                    value: subject,
-                });
-                return;
-            }
-            // check if this binding really exist in the database
-            // by example: find our category if its already bind in the database
-            const relationIdInDatabaseSubjectRelation = relatedEntityDatabaseRelationIds.find((relatedDatabaseEntityRelationId) => {
-                return OrmUtils_1.OrmUtils.compareIds(relationIdMap, relatedDatabaseEntityRelationId);
-            });
-            // if relationIdMap DOES NOT exist in the subject's relation in the database it means its a new relation and we need to "bind" them
-            // by example: this will tell category to insert into its post relation our post we are working with
-            //             relatedEntitySubject is newly inserted CategorySubject
-            //             relation.inverseRelation is ManyToOne relation inside Category
-            //             subject is Post needs to be inserted into Category
-            if (!relationIdInDatabaseSubjectRelation) {
-                // if there is no relatedEntitySubject then it means "category" wasn't persisted,
-                // but since we are going to update "category" table (since its an owning side of relation with join column)
-                // we create a new subject here:
-                if (!relatedEntitySubject) {
-                    relatedEntitySubject = new Subject_1.Subject({
-                        metadata: relation.inverseEntityMetadata,
-                        parentSubject: subject,
-                        canBeUpdated: true,
-                        identifier: relationIdMap,
-                    });
-                    this.subjects.push(relatedEntitySubject);
-                }
-                relatedEntitySubject.changeMaps.push({
-                    relation: relation.inverseRelation,
-                    value: subject,
-                });
-            }
-            // if related entity has relation id then we add it to the list of relation ids
-            // this list will be used later to compare with database relation ids to find a difference
-            // what exist in this array and does not exist in the database are newly inserted relations
-            // what does not exist in this array, but exist in the database are removed relations
-            // removed relations are set to null from inverse side of relation
-            relatedPersistedEntityRelationIds.push(relationIdMap);
-        });
-        // find what related entities were added and what were removed based on difference between what we save and what database has
-        if (relation.inverseRelation?.orphanedRowAction !== "disable") {
-            EntityMetadata_1.EntityMetadata.difference(relatedEntityDatabaseRelationIds, relatedPersistedEntityRelationIds).forEach((removedRelatedEntityRelationId) => {
-                // by example: removedRelatedEntityRelationId is category that was bind in the database before, but now its unbind
-                // todo: probably we can improve this in the future by finding entity with column those values,
-                // todo: maybe it was already in persistence process. This is possible due to unique requirements of join columns
-                // we create a new subject which operations will be executed in subject operation executor
-                const removedRelatedEntitySubject = new Subject_1.Subject({
-                    metadata: relation.inverseEntityMetadata,
-                    parentSubject: subject,
-                    identifier: removedRelatedEntityRelationId,
-                });
-                if (!relation.inverseRelation ||
-                    relation.inverseRelation.orphanedRowAction === "nullify") {
-                    removedRelatedEntitySubject.canBeUpdated = true;
-                    removedRelatedEntitySubject.changeMaps = [
-                        {
-                            relation: relation.inverseRelation,
-                            value: null,
-                        },
-                    ];
-                }
-                else if (relation.inverseRelation.orphanedRowAction === "delete") {
-                    removedRelatedEntitySubject.mustBeRemoved = true;
-                }
-                else if (relation.inverseRelation.orphanedRowAction === "soft-delete") {
-                    removedRelatedEntitySubject.canBeSoftRemoved = true;
-                }
-                this.subjects.push(removedRelatedEntitySubject);
-            });
-        }
-    }
-}
-exports.OneToManySubjectBuilder = OneToManySubjectBuilder;
-
-//# sourceMappingURL=OneToManySubjectBuilder.js.map

package/.output/server/node_modules/typeorm/persistence/subject-builder/OneToOneInverseSideSubjectBuilder.js

@@ -1,155 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OneToOneInverseSideSubjectBuilder = void 0;
-const Subject_1 = require("../Subject");
-const OrmUtils_1 = require("../../util/OrmUtils");
-/**
- * Builds operations needs to be executed for one-to-one non-owner relations of the given subjects.
- *
- * by example: post contains one-to-one non-owner relation with category in the property called "category", e.g.
- *             @OneToOne(type => Category, category => category.post) category: Category
- *             If user sets a category into the post and saves post we need to bind them.
- *             This operation requires updation of category table since its owner of the relation and contains a join column.
- *
- * note: this class shares lot of things with OneToManyUpdateBuilder, so when you change this class
- *       make sure to reflect changes there as well.
- */
-class OneToOneInverseSideSubjectBuilder {
-    // ---------------------------------------------------------------------
-    // Constructor
-    // ---------------------------------------------------------------------
-    constructor(subjects) {
-        this.subjects = subjects;
-    }
-    // ---------------------------------------------------------------------
-    // Public Methods
-    // ---------------------------------------------------------------------
-    /**
-     * Builds all required operations.
-     */
-    build() {
-        this.subjects.forEach((subject) => {
-            subject.metadata.oneToOneRelations.forEach((relation) => {
-                // we don't need owning relations, this operation is only for inverse side of one-to-one relations
-                // skip relations for which persistence is disabled
-                if (relation.isOwning || relation.persistenceEnabled === false)
-                    return;
-                this.buildForSubjectRelation(subject, relation);
-            });
-        });
-    }
-    // ---------------------------------------------------------------------
-    // Protected Methods
-    // ---------------------------------------------------------------------
-    /**
-     * Builds operations for a given subject and relation.
-     *
-     * by example: subject is "post" entity we are saving here and relation is "category" inside it here.
-     */
-    buildForSubjectRelation(subject, relation) {
-        // prepare objects (relation id map) for the database entity
-        // note: subject.databaseEntity contains relation with loaded relation id only (id map)
-        // by example: since subject is a post, we are expecting to get post's category saved in the database here,
-        //             particularly its relation id, e.g. category id stored in the database
-        let relatedEntityDatabaseRelationId = undefined;
-        if (subject.databaseEntity)
-            // related entity in the database can exist only if this entity (post) is saved
-            relatedEntityDatabaseRelationId = relation.getEntityValue(subject.databaseEntity);
-        // get related entities of persisted entity
-        // by example: get category from the passed to persist post entity
-        const relatedEntity = relation.getEntityValue(subject.entity); // by example: relatedEntity is a category here
-        if (relatedEntity === undefined)
-            // if relation is undefined then nothing to update
-            return;
-        // if related entity is null then we need to check if there a bind in the database and unset it
-        // if there is no bind in the entity then we don't need to do anything
-        // by example: if post.category = null and category has this post in the database then we unset it
-        if (relatedEntity === null) {
-            // it makes sense to update database only there is a previously set value in the database
-            if (relatedEntityDatabaseRelationId) {
-                // todo: probably we can improve this in the future by finding entity with column those values,
-                // todo: maybe it was already in persistence process. This is possible due to unique requirements of join columns
-                // we create a new subject which operations will be executed in subject operation executor
-                const removedRelatedEntitySubject = new Subject_1.Subject({
-                    metadata: relation.inverseEntityMetadata,
-                    parentSubject: subject,
-                    canBeUpdated: true,
-                    identifier: relatedEntityDatabaseRelationId,
-                    changeMaps: [
-                        {
-                            relation: relation.inverseRelation,
-                            value: null,
-                        },
-                    ],
-                });
-                this.subjects.push(removedRelatedEntitySubject);
-            }
-            return;
-        } // else means entity is bind in the database
-        // extract only relation id from the related entities, since we only need it for comparison
-        // by example: extract from category only relation id (category id, or let's say category title, depend on join column options)
-        let relationIdMap = relation.inverseEntityMetadata.getEntityIdMap(relatedEntity); // by example: relationIdMap is category.id map here, e.g. { id: ... }
-        // try to find a subject of this related entity, maybe it was loaded or was marked for persistence
-        let relatedEntitySubject = this.subjects.find((operateSubject) => {
-            return (!!operateSubject.entity &&
-                operateSubject.entity === relatedEntity);
-        });
-        // if subject with entity was found take subject identifier as relation id map since it may contain extra properties resolved
-        if (relatedEntitySubject)
-            relationIdMap = relatedEntitySubject.identifier;
-        // if relationIdMap is undefined then it means user binds object which is not saved in the database yet
-        // by example: if post contains category which does not have id(s) yet (because its a new category)
-        //             it means its always newly inserted and relation update operation always must be created for it
-        //             it does not make sense to perform difference operation for it for both add and remove actions
-        if (!relationIdMap) {
-            // we decided to remove this error because it brings complications when saving object with non-saved entities
-            // if related entity does not have a subject then it means user tries to bind entity which wasn't saved
-            // in this persistence because he didn't pass this entity for save or he did not set cascades
-            // but without entity being inserted we cannot bind it in the relation operation, so we throw an exception here
-            // if (!relatedEntitySubject)
-            //     throw new TypeORMError(`One-to-one inverse relation "${relation.entityMetadata.name}.${relation.propertyPath}" contains ` +
-            //         `entity which does not exist in the database yet, thus cannot be bind in the database. ` +
-            //         `Please setup cascade insertion or save entity before binding it.`);
-            if (!relatedEntitySubject)
-                return;
-            // okay, so related subject exist and its marked for insertion, then add a new change map
-            // by example: this will tell category to insert into its post relation our post we are working with
-            //             relatedEntitySubject is newly inserted CategorySubject
-            //             relation.inverseRelation is OneToOne owner relation inside Category
-            //             subject is Post needs to be inserted into Category
-            relatedEntitySubject.changeMaps.push({
-                relation: relation.inverseRelation,
-                value: subject,
-            });
-        }
-        // check if this binding really exist in the database
-        // by example: find our post if its already bind to category in the database and its not equal to what user tries to set
-        const areRelatedIdEqualWithDatabase = relatedEntityDatabaseRelationId &&
-            OrmUtils_1.OrmUtils.compareIds(relationIdMap, relatedEntityDatabaseRelationId);
-        // if they aren't equal it means its a new relation and we need to "bind" them
-        // by example: this will tell category to insert into its post relation our post we are working with
-        //             relatedEntitySubject is newly inserted CategorySubject
-        //             relation.inverseRelation is ManyToOne relation inside Category
-        //             subject is Post needs to be inserted into Category
-        if (!areRelatedIdEqualWithDatabase) {
-            // if there is no relatedEntitySubject then it means "category" wasn't persisted,
-            // but since we are going to update "category" table (since its an owning side of relation with join column)
-            // we create a new subject here:
-            if (!relatedEntitySubject) {
-                relatedEntitySubject = new Subject_1.Subject({
-                    metadata: relation.inverseEntityMetadata,
-                    canBeUpdated: true,
-                    identifier: relationIdMap,
-                });
-                this.subjects.push(relatedEntitySubject);
-            }
-            relatedEntitySubject.changeMaps.push({
-                relation: relation.inverseRelation,
-                value: subject,
-            });
-        }
-    }
-}
-exports.OneToOneInverseSideSubjectBuilder = OneToOneInverseSideSubjectBuilder;
-
-//# sourceMappingURL=OneToOneInverseSideSubjectBuilder.js.map

package/.output/server/node_modules/typeorm/persistence/tree/ClosureSubjectExecutor.js

@@ -1,241 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClosureSubjectExecutor = void 0;
-const CannotAttachTreeChildrenEntityError_1 = require("../../error/CannotAttachTreeChildrenEntityError");
-const OrmUtils_1 = require("../../util/OrmUtils");
-/**
- * Executes subject operations for closure entities.
- */
-class ClosureSubjectExecutor {
-    // -------------------------------------------------------------------------
-    // Constructor
-    // -------------------------------------------------------------------------
-    constructor(queryRunner) {
-        this.queryRunner = queryRunner;
-    }
-    // -------------------------------------------------------------------------
-    // Public Methods
-    // -------------------------------------------------------------------------
-    /**
-     * Executes operations when subject is being inserted.
-     */
-    async insert(subject) {
-        // create values to be inserted into the closure junction
-        const closureJunctionInsertMap = {};
-        subject.metadata.closureJunctionTable.ancestorColumns.forEach((column) => {
-            closureJunctionInsertMap[column.databaseName] =
-                subject.identifier;
-        });
-        subject.metadata.closureJunctionTable.descendantColumns.forEach((column) => {
-            closureJunctionInsertMap[column.databaseName] =
-                subject.identifier;
-        });
-        // insert values into the closure junction table
-        await this.queryRunner.manager
-            .createQueryBuilder()
-            .insert()
-            .into(subject.metadata.closureJunctionTable.tablePath)
-            .values(closureJunctionInsertMap)
-            .updateEntity(false)
-            .callListeners(false)
-            .execute();
-        let parent = subject.metadata.treeParentRelation.getEntityValue(subject.entity); // if entity was attached via parent
-        if (!parent && subject.parentSubject && subject.parentSubject.entity)
-            // if entity was attached via children
-            parent = subject.parentSubject.insertedValueSet
-                ? subject.parentSubject.insertedValueSet
-                : subject.parentSubject.entity;
-        if (parent) {
-            const escape = (alias) => this.queryRunner.connection.driver.escape(alias);
-            const tableName = this.getTableName(subject.metadata.closureJunctionTable.tablePath);
-            const queryParams = [];
-            const ancestorColumnNames = subject.metadata.closureJunctionTable.ancestorColumns.map((column) => {
-                return escape(column.databaseName);
-            });
-            const descendantColumnNames = subject.metadata.closureJunctionTable.descendantColumns.map((column) => {
-                return escape(column.databaseName);
-            });
-            const childEntityIds1 = subject.metadata.primaryColumns.map((column) => {
-                queryParams.push(column.getEntityValue(subject.insertedValueSet
-                    ? subject.insertedValueSet
-                    : subject.entity));
-                return this.queryRunner.connection.driver.createParameter("child_entity_" + column.databaseName, queryParams.length - 1);
-            });
-            const whereCondition = subject.metadata.closureJunctionTable.descendantColumns.map((column) => {
-                const columnName = escape(column.databaseName);
-                const parentId = column.referencedColumn.getEntityValue(parent);
-                if (!parentId)
-                    throw new CannotAttachTreeChildrenEntityError_1.CannotAttachTreeChildrenEntityError(subject.metadata.name);
-                queryParams.push(parentId);
-                const parameterName = this.queryRunner.connection.driver.createParameter("parent_entity_" +
-                    column.referencedColumn.databaseName, queryParams.length - 1);
-                return `${columnName} = ${parameterName}`;
-            });
-            await this.queryRunner.query(`INSERT INTO ${tableName} (${[
-                ...ancestorColumnNames,
-                ...descendantColumnNames,
-            ].join(", ")}) ` +
-                `SELECT ${ancestorColumnNames.join(", ")}, ${childEntityIds1.join(", ")} FROM ${tableName} WHERE ${whereCondition.join(" AND ")}`, queryParams);
-        }
-    }
-    /**
-     * Executes operations when subject is being updated.
-     */
-    async update(subject) {
-        let parent = subject.metadata.treeParentRelation.getEntityValue(subject.entity); // if entity was attached via parent
-        if (!parent && subject.parentSubject && subject.parentSubject.entity)
-            // if entity was attached via children
-            parent = subject.parentSubject.entity;
-        let entity = subject.databaseEntity; // if entity was attached via parent
-        if (!entity && parent)
-            // if entity was attached via children
-            entity = subject.metadata
-                .treeChildrenRelation.getEntityValue(parent)
-                .find((child) => {
-                return Object.entries(subject.identifier).every(([key, value]) => child[key] === value);
-            });
-        // Exit if the parent or the entity where never set
-        if (entity === undefined || parent === undefined) {
-            return;
-        }
-        const oldParent = subject.metadata.treeParentRelation.getEntityValue(entity);
-        const oldParentId = subject.metadata.getEntityIdMap(oldParent);
-        const parentId = subject.metadata.getEntityIdMap(parent);
-        // Exit if the new and old parents are the same
-        if (OrmUtils_1.OrmUtils.compareIds(oldParentId, parentId)) {
-            return;
-        }
-        const escape = (alias) => this.queryRunner.connection.driver.escape(alias);
-        const closureTable = subject.metadata.closureJunctionTable;
-        const ancestorColumnNames = closureTable.ancestorColumns.map((column) => {
-            return escape(column.databaseName);
-        });
-        const descendantColumnNames = closureTable.descendantColumns.map((column) => {
-            return escape(column.databaseName);
-        });
-        // Delete logic
-        const createSubQuery = (qb, alias) => {
-            const subAlias = `sub${alias}`;
-            const subSelect = qb
-                .createQueryBuilder()
-                .select(descendantColumnNames.join(", "))
-                .from(closureTable.tablePath, subAlias);
-            // Create where conditions e.g. (WHERE "subdescendant"."id_ancestor" = :value_id)
-            for (const column of closureTable.ancestorColumns) {
-                subSelect.andWhere(`${escape(subAlias)}.${escape(column.databaseName)} = :value_${column.referencedColumn.databaseName}`);
-            }
-            return qb
-                .createQueryBuilder()
-                .select(descendantColumnNames.join(", "))
-                .from(`(${subSelect.getQuery()})`, alias)
-                .setParameters(subSelect.getParameters())
-                .getQuery();
-        };
-        const parameters = {};
-        for (const column of subject.metadata.primaryColumns) {
-            parameters[`value_${column.databaseName}`] =
-                entity[column.databaseName];
-        }
-        await this.queryRunner.manager
-            .createQueryBuilder()
-            .delete()
-            .from(closureTable.tablePath)
-            .where((qb) => `(${descendantColumnNames.join(", ")}) IN (${createSubQuery(qb, "descendant")})`)
-            .andWhere((qb) => `(${ancestorColumnNames.join(", ")}) NOT IN (${createSubQuery(qb, "ancestor")})`)
-            .setParameters(parameters)
-            .execute();
-        /**
-         * Only insert new parent if it exits
-         *
-         * This only happens if the entity doesn't become a root entity
-         */
-        if (parent) {
-            // Insert logic
-            const queryParams = [];
-            const tableName = this.getTableName(closureTable.tablePath);
-            const superAlias = escape("supertree");
-            const subAlias = escape("subtree");
-            const select = [
-                ...ancestorColumnNames.map((columnName) => `${superAlias}.${columnName}`),
-                ...descendantColumnNames.map((columnName) => `${subAlias}.${columnName}`),
-            ];
-            const entityWhereCondition = subject.metadata.closureJunctionTable.ancestorColumns.map((column) => {
-                const columnName = escape(column.databaseName);
-                const entityId = column.referencedColumn.getEntityValue(entity);
-                queryParams.push(entityId);
-                const parameterName = this.queryRunner.connection.driver.createParameter("entity_" +
-                    column.referencedColumn.databaseName, queryParams.length - 1);
-                return `${subAlias}.${columnName} = ${parameterName}`;
-            });
-            const parentWhereCondition = subject.metadata.closureJunctionTable.descendantColumns.map((column) => {
-                const columnName = escape(column.databaseName);
-                const parentId = column.referencedColumn.getEntityValue(parent);
-                if (!parentId)
-                    throw new CannotAttachTreeChildrenEntityError_1.CannotAttachTreeChildrenEntityError(subject.metadata.name);
-                queryParams.push(parentId);
-                const parameterName = this.queryRunner.connection.driver.createParameter("parent_entity_" +
-                    column.referencedColumn.databaseName, queryParams.length - 1);
-                return `${superAlias}.${columnName} = ${parameterName}`;
-            });
-            await this.queryRunner.query(`INSERT INTO ${tableName} (${[
-                ...ancestorColumnNames,
-                ...descendantColumnNames,
-            ].join(", ")}) ` +
-                `SELECT ${select.join(", ")} ` +
-                `FROM ${tableName} AS ${superAlias}, ${tableName} AS ${subAlias} ` +
-                `WHERE ${[
-                    ...entityWhereCondition,
-                    ...parentWhereCondition,
-                ].join(" AND ")}`, queryParams);
-        }
-    }
-    /**
-     * Executes operations when subject is being removed.
-     */
-    async remove(subjects) {
-        // Only mssql need to execute deletes for the juntion table as it doesn't support multi cascade paths.
-        if (!(this.queryRunner.connection.driver.options.type === "mssql")) {
-            return;
-        }
-        if (!Array.isArray(subjects))
-            subjects = [subjects];
-        const escape = (alias) => this.queryRunner.connection.driver.escape(alias);
-        const identifiers = subjects.map((subject) => subject.identifier);
-        const closureTable = subjects[0].metadata.closureJunctionTable;
-        const generateWheres = (columns) => {
-            return columns
-                .map((column) => {
-                const data = identifiers.map((identifier) => identifier[column.referencedColumn.databaseName]);
-                return `${escape(column.databaseName)} IN (${data.join(", ")})`;
-            })
-                .join(" AND ");
-        };
-        const ancestorWhere = generateWheres(closureTable.ancestorColumns);
-        const descendantWhere = generateWheres(closureTable.descendantColumns);
-        await this.queryRunner.manager
-            .createQueryBuilder()
-            .delete()
-            .from(closureTable.tablePath)
-            .where(ancestorWhere)
-            .orWhere(descendantWhere)
-            .execute();
-    }
-    /**
-     * Gets escaped table name with schema name if SqlServer or Postgres driver used with custom
-     * schema name, otherwise returns escaped table name.
-     */
-    getTableName(tablePath) {
-        return tablePath
-            .split(".")
-            .map((i) => {
-            // this condition need because in SQL Server driver when custom database name was specified and schema name was not, we got `dbName..tableName` string, and doesn't need to escape middle empty string
-            return i === ""
-                ? i
-                : this.queryRunner.connection.driver.escape(i);
-        })
-            .join(".");
-    }
-}
-exports.ClosureSubjectExecutor = ClosureSubjectExecutor;
-
-//# sourceMappingURL=ClosureSubjectExecutor.js.map