orcaq 1.0.26 → 1.0.28

package/.output/server/node_modules/typeorm/query-builder/relation-count/RelationCountLoader.js

@@ -1,168 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RelationCountLoader = void 0;
-class RelationCountLoader {
-    // -------------------------------------------------------------------------
-    // Constructor
-    // -------------------------------------------------------------------------
-    constructor(connection, queryRunner, relationCountAttributes) {
-        this.connection = connection;
-        this.queryRunner = queryRunner;
-        this.relationCountAttributes = relationCountAttributes;
-    }
-    // -------------------------------------------------------------------------
-    // Public Methods
-    // -------------------------------------------------------------------------
-    async load(rawEntities) {
-        const onlyUnique = (value, index, self) => {
-            return self.indexOf(value) === index;
-        };
-        const promises = this.relationCountAttributes.map(async (relationCountAttr) => {
-            if (relationCountAttr.relation.isOneToMany) {
-                // example: Post and Category
-                // loadRelationCountAndMap("post.categoryCount", "post.categories")
-                // we expect it to load array of post ids
-                // todo(dima): fix issues wit multiple primary keys and remove joinColumns[0]
-                const relation = relationCountAttr.relation; // "category.posts"
-                const inverseRelation = relation.inverseRelation; // "post.category"
-                const referenceColumnName = inverseRelation.joinColumns[0].referencedColumn
-                    .propertyName; // post id
-                const inverseSideTable = relation.inverseEntityMetadata.target; // Post
-                const inverseSideTableName = relation.inverseEntityMetadata.tableName; // post
-                const inverseSideTableAlias = relationCountAttr.alias || inverseSideTableName; // if condition (custom query builder factory) is set then relationIdAttr.alias defined
-                const inverseSidePropertyName = inverseRelation.propertyName; // "category" from "post.category"
-                let referenceColumnValues = rawEntities
-                    .map((rawEntity) => rawEntity[relationCountAttr.parentAlias +
-                    "_" +
-                    referenceColumnName])
-                    .filter((value) => !!value);
-                referenceColumnValues =
-                    referenceColumnValues.filter(onlyUnique);
-                // ensure we won't perform redundant queries for joined data which was not found in selection
-                // example: if post.category was not found in db then no need to execute query for category.imageIds
-                if (referenceColumnValues.length === 0)
-                    return {
-                        relationCountAttribute: relationCountAttr,
-                        results: [],
-                    };
-                // generate query:
-                // SELECT category.post as parentId, COUNT(*) AS cnt FROM category category WHERE category.post IN (1, 2) GROUP BY category.post
-                const qb = this.connection.createQueryBuilder(this.queryRunner);
-                qb.select(inverseSideTableAlias + "." + inverseSidePropertyName, "parentId")
-                    .addSelect("COUNT(*)", "cnt")
-                    .from(inverseSideTable, inverseSideTableAlias)
-                    .where(inverseSideTableAlias +
-                    "." +
-                    inverseSidePropertyName +
-                    " IN (:...ids)")
-                    .addGroupBy(inverseSideTableAlias +
-                    "." +
-                    inverseSidePropertyName)
-                    .setParameter("ids", referenceColumnValues);
-                // apply condition (custom query builder factory)
-                if (relationCountAttr.queryBuilderFactory)
-                    relationCountAttr.queryBuilderFactory(qb);
-                return {
-                    relationCountAttribute: relationCountAttr,
-                    results: await qb.getRawMany(),
-                };
-            }
-            else {
-                // example: Post and Category
-                // owner side: loadRelationIdAndMap("post.categoryIds", "post.categories")
-                // inverse side: loadRelationIdAndMap("category.postIds", "category.posts")
-                // we expect it to load array of post ids
-                let joinTableColumnName;
-                let inverseJoinColumnName;
-                let firstJunctionColumn;
-                let secondJunctionColumn;
-                if (relationCountAttr.relation.isOwning) {
-                    // todo fix joinColumns[0] and inverseJoinColumns[0].
-                    joinTableColumnName =
-                        relationCountAttr.relation.joinColumns[0]
-                            .referencedColumn.databaseName;
-                    inverseJoinColumnName =
-                        relationCountAttr.relation.inverseJoinColumns[0]
-                            .referencedColumn.databaseName;
-                    firstJunctionColumn =
-                        relationCountAttr.relation.junctionEntityMetadata
-                            .columns[0];
-                    secondJunctionColumn =
-                        relationCountAttr.relation.junctionEntityMetadata
-                            .columns[1];
-                }
-                else {
-                    joinTableColumnName =
-                        relationCountAttr.relation.inverseRelation
-                            .inverseJoinColumns[0].referencedColumn
-                            .databaseName;
-                    inverseJoinColumnName =
-                        relationCountAttr.relation.inverseRelation
-                            .joinColumns[0].referencedColumn.databaseName;
-                    firstJunctionColumn =
-                        relationCountAttr.relation.junctionEntityMetadata
-                            .columns[1];
-                    secondJunctionColumn =
-                        relationCountAttr.relation.junctionEntityMetadata
-                            .columns[0];
-                }
-                let referenceColumnValues = rawEntities
-                    .map((rawEntity) => rawEntity[relationCountAttr.parentAlias +
-                    "_" +
-                    joinTableColumnName])
-                    .filter((value) => !!value);
-                referenceColumnValues =
-                    referenceColumnValues.filter(onlyUnique);
-                // ensure we won't perform redundant queries for joined data which was not found in selection
-                // example: if post.category was not found in db then no need to execute query for category.imageIds
-                if (referenceColumnValues.length === 0)
-                    return {
-                        relationCountAttribute: relationCountAttr,
-                        results: [],
-                    };
-                const junctionAlias = relationCountAttr.junctionAlias;
-                const inverseSideTableName = relationCountAttr.joinInverseSideMetadata.tableName;
-                const inverseSideTableAlias = relationCountAttr.alias || inverseSideTableName;
-                const junctionTableName = relationCountAttr.relation.junctionEntityMetadata
-                    .tableName;
-                const condition = junctionAlias +
-                    "." +
-                    firstJunctionColumn.propertyName +
-                    " IN (" +
-                    referenceColumnValues.map((vals) => isNaN(vals) ? "'" + vals + "'" : vals) +
-                    ")" +
-                    " AND " +
-                    junctionAlias +
-                    "." +
-                    secondJunctionColumn.propertyName +
-                    " = " +
-                    inverseSideTableAlias +
-                    "." +
-                    inverseJoinColumnName;
-                const qb = this.connection.createQueryBuilder(this.queryRunner);
-                qb.select(junctionAlias + "." + firstJunctionColumn.propertyName, "parentId")
-                    .addSelect("COUNT(" +
-                    qb.escape(inverseSideTableAlias) +
-                    "." +
-                    qb.escape(inverseJoinColumnName) +
-                    ")", "cnt")
-                    .from(inverseSideTableName, inverseSideTableAlias)
-                    .innerJoin(junctionTableName, junctionAlias, condition)
-                    .addGroupBy(junctionAlias +
-                    "." +
-                    firstJunctionColumn.propertyName);
-                // apply condition (custom query builder factory)
-                if (relationCountAttr.queryBuilderFactory)
-                    relationCountAttr.queryBuilderFactory(qb);
-                return {
-                    relationCountAttribute: relationCountAttr,
-                    results: await qb.getRawMany(),
-                };
-            }
-        });
-        return Promise.all(promises);
-    }
-}
-exports.RelationCountLoader = RelationCountLoader;
-
-//# sourceMappingURL=RelationCountLoader.js.map

package/.output/server/node_modules/typeorm/query-builder/relation-count/RelationCountMetadataToAttributeTransformer.js

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RelationCountMetadataToAttributeTransformer = void 0;
-const RelationCountAttribute_1 = require("./RelationCountAttribute");
-class RelationCountMetadataToAttributeTransformer {
-    // -------------------------------------------------------------------------
-    // Constructor
-    // -------------------------------------------------------------------------
-    constructor(expressionMap) {
-        this.expressionMap = expressionMap;
-    }
-    // -------------------------------------------------------------------------
-    // Public Methods
-    // -------------------------------------------------------------------------
-    transform() {
-        // by example:
-        // post has relation count:
-        // @RelationCount(post => post.categories) categoryCount
-        // category has relation count
-        // @RelationCount(category => category.images) imageCount
-        // we load post and join category
-        // we expect post.categoryCount and post.category.imageCount to have relation counts
-        // first create relation count attributes for all relation count metadatas of the main selected object (post from example)
-        if (this.expressionMap.mainAlias) {
-            this.expressionMap.mainAlias.metadata.relationCounts.forEach((relationCount) => {
-                const attribute = this.metadataToAttribute(this.expressionMap.mainAlias.name, relationCount);
-                this.expressionMap.relationCountAttributes.push(attribute);
-            });
-        }
-        // second create relation count attributes for all relation count metadatas of all joined objects (category from example)
-        this.expressionMap.joinAttributes.forEach((join) => {
-            // ensure this join has a metadata, because relation count can only work for real orm entities
-            if (!join.metadata || join.metadata.isJunction)
-                return;
-            join.metadata.relationCounts.forEach((relationCount) => {
-                const attribute = this.metadataToAttribute(join.alias.name, relationCount);
-                this.expressionMap.relationCountAttributes.push(attribute);
-            });
-        });
-    }
-    // -------------------------------------------------------------------------
-    // Private Methods
-    // -------------------------------------------------------------------------
-    metadataToAttribute(parentAliasName, relationCount) {
-        return new RelationCountAttribute_1.RelationCountAttribute(this.expressionMap, {
-            relationName: parentAliasName + "." + relationCount.relation.propertyName, // category.images
-            mapToProperty: parentAliasName + "." + relationCount.propertyName, // category.imageIds
-            alias: relationCount.alias,
-            queryBuilderFactory: relationCount.queryBuilderFactory,
-        });
-    }
-}
-exports.RelationCountMetadataToAttributeTransformer = RelationCountMetadataToAttributeTransformer;
-
-//# sourceMappingURL=RelationCountMetadataToAttributeTransformer.js.map

package/.output/server/node_modules/typeorm/query-builder/relation-id/RelationIdAttribute.js

@@ -1,88 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RelationIdAttribute = void 0;
-const QueryBuilderUtils_1 = require("../QueryBuilderUtils");
-const ObjectUtils_1 = require("../../util/ObjectUtils");
-const TypeORMError_1 = require("../../error/TypeORMError");
-/**
- * Stores all join relation id attributes which will be used to build a JOIN query.
- */
-class RelationIdAttribute {
-    // -------------------------------------------------------------------------
-    // Constructor
-    // -------------------------------------------------------------------------
-    constructor(queryExpressionMap, relationIdAttribute) {
-        this.queryExpressionMap = queryExpressionMap;
-        /**
-         * Indicates if relation id should NOT be loaded as id map.
-         */
-        this.disableMixedMap = false;
-        ObjectUtils_1.ObjectUtils.assign(this, relationIdAttribute || {});
-    }
-    // -------------------------------------------------------------------------
-    // Public Methods
-    // -------------------------------------------------------------------------
-    get joinInverseSideMetadata() {
-        return this.relation.inverseEntityMetadata;
-    }
-    /**
-     * Alias of the parent of this join.
-     * For example, if we join ("post.category", "categoryAlias") then "post" is a parent alias.
-     * This value is extracted from entityOrProperty value.
-     * This is available when join was made using "post.category" syntax.
-     */
-    get parentAlias() {
-        if (!QueryBuilderUtils_1.QueryBuilderUtils.isAliasProperty(this.relationName))
-            throw new TypeORMError_1.TypeORMError(`Given value must be a string representation of alias property`);
-        return this.relationName.substr(0, this.relationName.indexOf("."));
-    }
-    /**
-     * Relation property name of the parent.
-     * This is used to understand what is joined.
-     * For example, if we join ("post.category", "categoryAlias") then "category" is a relation property.
-     * This value is extracted from entityOrProperty value.
-     * This is available when join was made using "post.category" syntax.
-     */
-    get relationPropertyPath() {
-        if (!QueryBuilderUtils_1.QueryBuilderUtils.isAliasProperty(this.relationName))
-            throw new TypeORMError_1.TypeORMError(`Given value must be a string representation of alias property`);
-        return this.relationName.substr(this.relationName.indexOf(".") + 1);
-    }
-    /**
-     * Relation of the parent.
-     * This is used to understand what is joined.
-     * This is available when join was made using "post.category" syntax.
-     */
-    get relation() {
-        if (!QueryBuilderUtils_1.QueryBuilderUtils.isAliasProperty(this.relationName))
-            throw new TypeORMError_1.TypeORMError(`Given value must be a string representation of alias property`);
-        const relationOwnerSelection = this.queryExpressionMap.findAliasByName(this.parentAlias);
-        const relation = relationOwnerSelection.metadata.findRelationWithPropertyPath(this.relationPropertyPath);
-        if (!relation)
-            throw new TypeORMError_1.TypeORMError(`Relation with property path ${this.relationPropertyPath} in entity was not found.`);
-        return relation;
-    }
-    /**
-     * Generates alias of junction table, whose ids we get.
-     */
-    get junctionAlias() {
-        const [parentAlias, relationProperty] = this.relationName.split(".");
-        return parentAlias + "_" + relationProperty + "_rid";
-    }
-    /**
-     * Metadata of the joined entity.
-     * If extra condition without entity was joined, then it will return undefined.
-     */
-    get junctionMetadata() {
-        return this.relation.junctionEntityMetadata;
-    }
-    get mapToPropertyParentAlias() {
-        return this.mapToProperty.substr(0, this.mapToProperty.indexOf("."));
-    }
-    get mapToPropertyPropertyPath() {
-        return this.mapToProperty.substr(this.mapToProperty.indexOf(".") + 1);
-    }
-}
-exports.RelationIdAttribute = RelationIdAttribute;
-
-//# sourceMappingURL=RelationIdAttribute.js.map

package/.output/server/node_modules/typeorm/query-builder/relation-id/RelationIdLoader.js

@@ -1,275 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RelationIdLoader = void 0;
-const DriverUtils_1 = require("../../driver/DriverUtils");
-const TypeORMError_1 = require("../../error/TypeORMError");
-const OrmUtils_1 = require("../../util/OrmUtils");
-class RelationIdLoader {
-    // -------------------------------------------------------------------------
-    // Constructor
-    // -------------------------------------------------------------------------
-    constructor(connection, queryRunner, relationIdAttributes) {
-        this.connection = connection;
-        this.queryRunner = queryRunner;
-        this.relationIdAttributes = relationIdAttributes;
-    }
-    // -------------------------------------------------------------------------
-    // Public Methods
-    // -------------------------------------------------------------------------
-    async load(rawEntities) {
-        const promises = this.relationIdAttributes.map(async (relationIdAttr) => {
-            if (relationIdAttr.relation.isManyToOne ||
-                relationIdAttr.relation.isOneToOneOwner) {
-                // example: Post and Tag
-                // loadRelationIdAndMap("post.tagId", "post.tag")
-                // we expect it to load id of tag
-                if (relationIdAttr.queryBuilderFactory)
-                    throw new TypeORMError_1.TypeORMError("Additional condition can not be used with ManyToOne or OneToOne owner relations.");
-                const duplicates = {};
-                const results = rawEntities
-                    .map((rawEntity) => {
-                    const result = {};
-                    const duplicateParts = [];
-                    relationIdAttr.relation.joinColumns.forEach((joinColumn) => {
-                        result[joinColumn.databaseName] =
-                            this.connection.driver.prepareHydratedValue(rawEntity[DriverUtils_1.DriverUtils.buildAlias(this.connection.driver, undefined, relationIdAttr.parentAlias, joinColumn.databaseName)], joinColumn.referencedColumn);
-                        const duplicatePart = `${joinColumn.databaseName}:${result[joinColumn.databaseName]}`;
-                        if (duplicateParts.indexOf(duplicatePart) === -1) {
-                            duplicateParts.push(duplicatePart);
-                        }
-                    });
-                    relationIdAttr.relation.entityMetadata.primaryColumns.forEach((primaryColumn) => {
-                        result[primaryColumn.databaseName] =
-                            this.connection.driver.prepareHydratedValue(rawEntity[DriverUtils_1.DriverUtils.buildAlias(this.connection.driver, undefined, relationIdAttr.parentAlias, primaryColumn.databaseName)], primaryColumn);
-                        const duplicatePart = `${primaryColumn.databaseName}:${result[primaryColumn.databaseName]}`;
-                        if (duplicateParts.indexOf(duplicatePart) === -1) {
-                            duplicateParts.push(duplicatePart);
-                        }
-                    });
-                    duplicateParts.sort();
-                    const duplicate = duplicateParts.join("::");
-                    if (duplicates[duplicate]) {
-                        return null;
-                    }
-                    duplicates[duplicate] = true;
-                    return result;
-                })
-                    .filter((v) => v);
-                return {
-                    relationIdAttribute: relationIdAttr,
-                    results: results,
-                };
-            }
-            else if (relationIdAttr.relation.isOneToMany ||
-                relationIdAttr.relation.isOneToOneNotOwner) {
-                // example: Post and Category
-                // loadRelationIdAndMap("post.categoryIds", "post.categories")
-                // we expect it to load array of category ids
-                const relation = relationIdAttr.relation; // "post.categories"
-                const joinColumns = relation.isOwning
-                    ? relation.joinColumns
-                    : relation.inverseRelation.joinColumns;
-                const table = relation.inverseEntityMetadata.target; // category
-                const tableName = relation.inverseEntityMetadata.tableName; // category
-                const tableAlias = relationIdAttr.alias || tableName; // if condition (custom query builder factory) is set then relationIdAttr.alias defined
-                const duplicates = {};
-                const parameters = {};
-                const condition = rawEntities
-                    .map((rawEntity, index) => {
-                    const duplicateParts = [];
-                    const parameterParts = {};
-                    const queryPart = joinColumns
-                        .map((joinColumn) => {
-                        const parameterName = joinColumn.databaseName + index;
-                        const parameterValue = rawEntity[DriverUtils_1.DriverUtils.buildAlias(this.connection.driver, undefined, relationIdAttr.parentAlias, joinColumn.referencedColumn
-                            .databaseName)];
-                        const duplicatePart = `${tableAlias}:${joinColumn.propertyPath}:${parameterValue}`;
-                        if (duplicateParts.indexOf(duplicatePart) !== -1) {
-                            return "";
-                        }
-                        duplicateParts.push(duplicatePart);
-                        parameterParts[parameterName] =
-                            parameterValue;
-                        return (tableAlias +
-                            "." +
-                            joinColumn.propertyPath +
-                            " = :" +
-                            parameterName);
-                    })
-                        .filter((v) => v)
-                        .join(" AND ");
-                    duplicateParts.sort();
-                    const duplicate = duplicateParts.join("::");
-                    if (duplicates[duplicate]) {
-                        return "";
-                    }
-                    duplicates[duplicate] = true;
-                    Object.assign(parameters, parameterParts);
-                    return queryPart;
-                })
-                    .filter((v) => v)
-                    .map((condition) => "(" + condition + ")")
-                    .join(" OR ");
-                // ensure we won't perform redundant queries for joined data which was not found in selection
-                // example: if post.category was not found in db then no need to execute query for category.imageIds
-                if (!condition)
-                    return {
-                        relationIdAttribute: relationIdAttr,
-                        results: [],
-                    };
-                // generate query:
-                // SELECT category.id, category.postId FROM category category ON category.postId = :postId
-                const qb = this.connection.createQueryBuilder(this.queryRunner);
-                const columns = OrmUtils_1.OrmUtils.uniq([
-                    ...joinColumns,
-                    ...relation.inverseRelation.entityMetadata
-                        .primaryColumns,
-                ], (column) => column.propertyPath);
-                columns.forEach((joinColumn) => {
-                    qb.addSelect(tableAlias + "." + joinColumn.propertyPath, joinColumn.databaseName);
-                });
-                qb.from(table, tableAlias)
-                    .where("(" + condition + ")") // need brackets because if we have additional condition and no brackets, it looks like (a = 1) OR (a = 2) AND b = 1, that is incorrect
-                    .setParameters(parameters);
-                // apply condition (custom query builder factory)
-                if (relationIdAttr.queryBuilderFactory)
-                    relationIdAttr.queryBuilderFactory(qb);
-                const results = await qb.getRawMany();
-                results.forEach((result) => {
-                    joinColumns.forEach((column) => {
-                        result[column.databaseName] =
-                            this.connection.driver.prepareHydratedValue(result[column.databaseName], column.referencedColumn);
-                    });
-                    relation.inverseRelation.entityMetadata.primaryColumns.forEach((column) => {
-                        result[column.databaseName] =
-                            this.connection.driver.prepareHydratedValue(result[column.databaseName], column);
-                    });
-                });
-                return {
-                    relationIdAttribute: relationIdAttr,
-                    results,
-                };
-            }
-            else {
-                // many-to-many
-                // example: Post and Category
-                // owner side: loadRelationIdAndMap("post.categoryIds", "post.categories")
-                // inverse side: loadRelationIdAndMap("category.postIds", "category.posts")
-                // we expect it to load array of post ids
-                const relation = relationIdAttr.relation;
-                const joinColumns = relation.isOwning
-                    ? relation.joinColumns
-                    : relation.inverseRelation.inverseJoinColumns;
-                const inverseJoinColumns = relation.isOwning
-                    ? relation.inverseJoinColumns
-                    : relation.inverseRelation.joinColumns;
-                const junctionAlias = relationIdAttr.junctionAlias;
-                const inverseSideTableName = relationIdAttr.joinInverseSideMetadata.tableName;
-                const inverseSideTableAlias = relationIdAttr.alias || inverseSideTableName;
-                const junctionTableName = relation.isOwning
-                    ? relation.junctionEntityMetadata.tableName
-                    : relation.inverseRelation.junctionEntityMetadata
-                        .tableName;
-                const mappedColumns = rawEntities.map((rawEntity) => {
-                    return joinColumns.reduce((map, joinColumn) => {
-                        map[joinColumn.propertyPath] =
-                            rawEntity[DriverUtils_1.DriverUtils.buildAlias(this.connection.driver, undefined, relationIdAttr.parentAlias, joinColumn.referencedColumn
-                                .databaseName)];
-                        return map;
-                    }, {});
-                });
-                // ensure we won't perform redundant queries for joined data which was not found in selection
-                // example: if post.category was not found in db then no need to execute query for category.imageIds
-                if (mappedColumns.length === 0)
-                    return {
-                        relationIdAttribute: relationIdAttr,
-                        results: [],
-                    };
-                const parameters = {};
-                const duplicates = {};
-                const joinColumnConditions = mappedColumns
-                    .map((mappedColumn, index) => {
-                    const duplicateParts = [];
-                    const parameterParts = {};
-                    const queryPart = Object.keys(mappedColumn)
-                        .map((key) => {
-                        const parameterName = key + index;
-                        const parameterValue = mappedColumn[key];
-                        const duplicatePart = `${junctionAlias}:${key}:${parameterValue}`;
-                        if (duplicateParts.indexOf(duplicatePart) !== -1) {
-                            return "";
-                        }
-                        duplicateParts.push(duplicatePart);
-                        parameterParts[parameterName] =
-                            parameterValue;
-                        return (junctionAlias +
-                            "." +
-                            key +
-                            " = :" +
-                            parameterName);
-                    })
-                        .filter((s) => s)
-                        .join(" AND ");
-                    duplicateParts.sort();
-                    const duplicate = duplicateParts.join("::");
-                    if (duplicates[duplicate]) {
-                        return "";
-                    }
-                    duplicates[duplicate] = true;
-                    Object.assign(parameters, parameterParts);
-                    return queryPart;
-                })
-                    .filter((s) => s);
-                const inverseJoinColumnCondition = inverseJoinColumns
-                    .map((joinColumn) => {
-                    return (junctionAlias +
-                        "." +
-                        joinColumn.propertyPath +
-                        " = " +
-                        inverseSideTableAlias +
-                        "." +
-                        joinColumn.referencedColumn.propertyPath);
-                })
-                    .join(" AND ");
-                const condition = joinColumnConditions
-                    .map((condition) => {
-                    return ("(" +
-                        condition +
-                        " AND " +
-                        inverseJoinColumnCondition +
-                        ")");
-                })
-                    .join(" OR ");
-                const qb = this.connection.createQueryBuilder(this.queryRunner);
-                inverseJoinColumns.forEach((joinColumn) => {
-                    qb.addSelect(junctionAlias + "." + joinColumn.propertyPath, joinColumn.databaseName).addOrderBy(junctionAlias + "." + joinColumn.propertyPath);
-                });
-                joinColumns.forEach((joinColumn) => {
-                    qb.addSelect(junctionAlias + "." + joinColumn.propertyPath, joinColumn.databaseName).addOrderBy(junctionAlias + "." + joinColumn.propertyPath);
-                });
-                qb.from(inverseSideTableName, inverseSideTableAlias)
-                    .innerJoin(junctionTableName, junctionAlias, condition)
-                    .setParameters(parameters);
-                // apply condition (custom query builder factory)
-                if (relationIdAttr.queryBuilderFactory)
-                    relationIdAttr.queryBuilderFactory(qb);
-                const results = await qb.getRawMany();
-                results.forEach((result) => {
-                    ;
-                    [...joinColumns, ...inverseJoinColumns].forEach((column) => {
-                        result[column.databaseName] =
-                            this.connection.driver.prepareHydratedValue(result[column.databaseName], column.referencedColumn);
-                    });
-                });
-                return {
-                    relationIdAttribute: relationIdAttr,
-                    results,
-                };
-            }
-        });
-        return Promise.all(promises);
-    }
-}
-exports.RelationIdLoader = RelationIdLoader;
-
-//# sourceMappingURL=RelationIdLoader.js.map

package/.output/server/node_modules/typeorm/query-builder/relation-id/RelationIdMetadataToAttributeTransformer.js

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RelationIdMetadataToAttributeTransformer = void 0;
-const RelationIdAttribute_1 = require("./RelationIdAttribute");
-class RelationIdMetadataToAttributeTransformer {
-    // -------------------------------------------------------------------------
-    // Constructor
-    // -------------------------------------------------------------------------
-    constructor(expressionMap) {
-        this.expressionMap = expressionMap;
-    }
-    // -------------------------------------------------------------------------
-    // Public Methods
-    // -------------------------------------------------------------------------
-    transform() {
-        // by example:
-        // post has relation id:
-        // @RelationId(post => post.categories) categoryIds
-        // category has relation id
-        // @RelationId(category => category.images) imageIds
-        // we load post and join category
-        // we expect post.categoryIds and post.category.imageIds to have relation ids
-        // first create relation id attributes for all relation id metadatas of the main selected object (post from example)
-        if (this.expressionMap.mainAlias) {
-            this.expressionMap.mainAlias.metadata.relationIds.forEach((relationId) => {
-                const attribute = this.metadataToAttribute(this.expressionMap.mainAlias.name, relationId);
-                this.expressionMap.relationIdAttributes.push(attribute);
-            });
-        }
-        // second create relation id attributes for all relation id metadatas of all joined objects (category from example)
-        this.expressionMap.joinAttributes.forEach((join) => {
-            // ensure this join has a metadata, because relation id can only work for real orm entities
-            if (!join.metadata || join.metadata.isJunction)
-                return;
-            join.metadata.relationIds.forEach((relationId) => {
-                const attribute = this.metadataToAttribute(join.alias.name, relationId);
-                this.expressionMap.relationIdAttributes.push(attribute);
-            });
-        });
-    }
-    // -------------------------------------------------------------------------
-    // Private Methods
-    // -------------------------------------------------------------------------
-    metadataToAttribute(parentAliasName, relationId) {
-        return new RelationIdAttribute_1.RelationIdAttribute(this.expressionMap, {
-            relationName: parentAliasName + "." + relationId.relation.propertyName, // category.images
-            mapToProperty: parentAliasName + "." + relationId.propertyName, // category.imageIds
-            alias: relationId.alias,
-            queryBuilderFactory: relationId.queryBuilderFactory,
-        });
-    }
-}
-exports.RelationIdMetadataToAttributeTransformer = RelationIdMetadataToAttributeTransformer;
-
-//# sourceMappingURL=RelationIdMetadataToAttributeTransformer.js.map

package/.output/server/node_modules/typeorm/query-builder/result/DeleteResult.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeleteResult = void 0;
-/**
- * Result object returned by DeleteQueryBuilder execution.
- */
-class DeleteResult {
-    static from(queryResult) {
-        const result = new this();
-        result.raw = queryResult.records;
-        result.affected = queryResult.affected;
-        return result;
-    }
-}
-exports.DeleteResult = DeleteResult;
-
-//# sourceMappingURL=DeleteResult.js.map