@depup/typeorm 0.3.28-depup.0

package/browser/query-builder/relation-count/RelationCountLoader.js

@@ -0,0 +1,164 @@
+export 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);
+    }
+}
+
+//# sourceMappingURL=RelationCountLoader.js.map

package/browser/query-builder/relation-count/RelationCountLoader.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../browser/src/query-builder/relation-count/RelationCountLoader.ts"],"names":[],"mappings":"AAMA,MAAM,OAAO,mBAAmB;IAC5B,4EAA4E;IAC5E,cAAc;IACd,4EAA4E;IAE5E,YACc,UAAsB,EACtB,WAAoC,EACpC,uBAAiD;QAFjD,eAAU,GAAV,UAAU,CAAY;QACtB,gBAAW,GAAX,WAAW,CAAyB;QACpC,4BAAuB,GAAvB,uBAAuB,CAA0B;IAC5D,CAAC;IAEJ,4EAA4E;IAC5E,iBAAiB;IACjB,4EAA4E;IAE5E,KAAK,CAAC,IAAI,CAAC,WAAkB;QACzB,MAAM,UAAU,GAAG,CAAC,KAAU,EAAE,KAAa,EAAE,IAAS,EAAE,EAAE;YACxD,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,KAAK,CAAA;QACxC,CAAC,CAAA;QAED,MAAM,QAAQ,GAAG,IAAI,CAAC,uBAAuB,CAAC,GAAG,CAC7C,KAAK,EAAE,iBAAiB,EAAE,EAAE;YACxB,IAAI,iBAAiB,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC;gBACzC,6BAA6B;gBAC7B,mEAAmE;gBACnE,yCAAyC;gBAEzC,6EAA6E;gBAC7E,MAAM,QAAQ,GAAG,iBAAiB,CAAC,QAAQ,CAAA,CAAC,mBAAmB;gBAC/D,MAAM,eAAe,GAAG,QAAQ,CAAC,eAAgB,CAAA,CAAC,kBAAkB;gBACpE,MAAM,mBAAmB,GACrB,eAAe,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,gBAAiB;qBAC3C,YAAY,CAAA,CAAC,UAAU;gBAChC,MAAM,gBAAgB,GAClB,QAAQ,CAAC,qBAAqB,CAAC,MAAM,CAAA,CAAC,OAAO;gBACjD,MAAM,oBAAoB,GACtB,QAAQ,CAAC,qBAAqB,CAAC,SAAS,CAAA,CAAC,OAAO;gBACpD,MAAM,qBAAqB,GACvB,iBAAiB,CAAC,KAAK,IAAI,oBAAoB,CAAA,CAAC,uFAAuF;gBAC3I,MAAM,uBAAuB,GAAG,eAAe,CAAC,YAAY,CAAA,CAAC,kCAAkC;gBAE/F,IAAI,qBAAqB,GAAG,WAAW;qBAClC,GAAG,CACA,CAAC,SAAS,EAAE,EAAE,CACV,SAAS,CACL,iBAAiB,CAAC,WAAW;oBACzB,GAAG;oBACH,mBAAmB,CAC1B,CACR;qBACA,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAA;gBAC/B,qBAAqB;oBACjB,qBAAqB,CAAC,MAAM,CAAC,UAAU,CAAC,CAAA;gBAE5C,6FAA6F;gBAC7F,oGAAoG;gBACpG,IAAI,qBAAqB,CAAC,MAAM,KAAK,CAAC;oBAClC,OAAO;wBACH,sBAAsB,EAAE,iBAAiB;wBACzC,OAAO,EAAE,EAAE;qBACd,CAAA;gBAEL,kBAAkB;gBAClB,gIAAgI;gBAChI,MAAM,EAAE,GAAG,IAAI,CAAC,UAAU,CAAC,kBAAkB,CACzC,IAAI,CAAC,WAAW,CACnB,CAAA;gBACD,EAAE,CAAC,MAAM,CACL,qBAAqB,GAAG,GAAG,GAAG,uBAAuB,EACrD,UAAU,CACb;qBACI,SAAS,CAAC,UAAU,EAAE,KAAK,CAAC;qBAC5B,IAAI,CAAC,gBAAgB,EAAE,qBAAqB,CAAC;qBAC7C,KAAK,CACF,qBAAqB;oBACjB,GAAG;oBACH,uBAAuB;oBACvB,eAAe,CACtB;qBACA,UAAU,CACP,qBAAqB;oBACjB,GAAG;oBACH,uBAAuB,CAC9B;qBACA,YAAY,CAAC,KAAK,EAAE,qBAAqB,CAAC,CAAA;gBAE/C,iDAAiD;gBACjD,IAAI,iBAAiB,CAAC,mBAAmB;oBACrC,iBAAiB,CAAC,mBAAmB,CAAC,EAAE,CAAC,CAAA;gBAE7C,OAAO;oBACH,sBAAsB,EAAE,iBAAiB;oBACzC,OAAO,EAAE,MAAM,EAAE,CAAC,UAAU,EAAE;iBACjC,CAAA;YACL,CAAC;iBAAM,CAAC;gBACJ,6BAA6B;gBAC7B,0EAA0E;gBAC1E,2EAA2E;gBAC3E,yCAAyC;gBAEzC,IAAI,mBAA2B,CAAA;gBAC/B,IAAI,qBAA6B,CAAA;gBACjC,IAAI,mBAAmC,CAAA;gBACvC,IAAI,oBAAoC,CAAA;gBAExC,IAAI,iBAAiB,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC;oBACtC,qDAAqD;oBACrD,mBAAmB;wBACf,iBAAiB,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC;6BACpC,gBAAiB,CAAC,YAAY,CAAA;oBACvC,qBAAqB;wBACjB,iBAAiB,CAAC,QAAQ,CAAC,kBAAkB,CAAC,CAAC,CAAC;6BAC3C,gBAAiB,CAAC,YAAY,CAAA;oBACvC,mBAAmB;wBACf,iBAAiB,CAAC,QAAQ,CAAC,sBAAuB;6BAC7C,OAAO,CAAC,CAAC,CAAC,CAAA;oBACnB,oBAAoB;wBAChB,iBAAiB,CAAC,QAAQ,CAAC,sBAAuB;6BAC7C,OAAO,CAAC,CAAC,CAAC,CAAA;gBACvB,CAAC;qBAAM,CAAC;oBACJ,mBAAmB;wBACf,iBAAiB,CAAC,QAAQ,CAAC,eAAgB;6BACtC,kBAAkB,CAAC,CAAC,CAAC,CAAC,gBAAiB;6BACvC,YAAY,CAAA;oBACrB,qBAAqB;wBACjB,iBAAiB,CAAC,QAAQ,CAAC,eAAgB;6BACtC,WAAW,CAAC,CAAC,CAAC,CAAC,gBAAiB,CAAC,YAAY,CAAA;oBACtD,mBAAmB;wBACf,iBAAiB,CAAC,QAAQ,CAAC,sBAAuB;6BAC7C,OAAO,CAAC,CAAC,CAAC,CAAA;oBACnB,oBAAoB;wBAChB,iBAAiB,CAAC,QAAQ,CAAC,sBAAuB;6BAC7C,OAAO,CAAC,CAAC,CAAC,CAAA;gBACvB,CAAC;gBAED,IAAI,qBAAqB,GAAG,WAAW;qBAClC,GAAG,CACA,CAAC,SAAS,EAAE,EAAE,CACV,SAAS,CACL,iBAAiB,CAAC,WAAW;oBACzB,GAAG;oBACH,mBAAmB,CAC1B,CACR;qBACA,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAA;gBAC/B,qBAAqB;oBACjB,qBAAqB,CAAC,MAAM,CAAC,UAAU,CAAC,CAAA;gBAE5C,6FAA6F;gBAC7F,oGAAoG;gBACpG,IAAI,qBAAqB,CAAC,MAAM,KAAK,CAAC;oBAClC,OAAO;wBACH,sBAAsB,EAAE,iBAAiB;wBACzC,OAAO,EAAE,EAAE;qBACd,CAAA;gBAEL,MAAM,aAAa,GAAG,iBAAiB,CAAC,aAAa,CAAA;gBACrD,MAAM,oBAAoB,GACtB,iBAAiB,CAAC,uBAAuB,CAAC,SAAS,CAAA;gBACvD,MAAM,qBAAqB,GACvB,iBAAiB,CAAC,KAAK,IAAI,oBAAoB,CAAA;gBACnD,MAAM,iBAAiB,GACnB,iBAAiB,CAAC,QAAQ,CAAC,sBAAuB;qBAC7C,SAAS,CAAA;gBAElB,MAAM,SAAS,GACX,aAAa;oBACb,GAAG;oBACH,mBAAmB,CAAC,YAAY;oBAChC,OAAO;oBACP,qBAAqB,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAC/B,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,IAAI,GAAG,GAAG,CAAC,CAAC,CAAC,IAAI,CACxC;oBACD,GAAG;oBACH,OAAO;oBACP,aAAa;oBACb,GAAG;oBACH,oBAAoB,CAAC,YAAY;oBACjC,KAAK;oBACL,qBAAqB;oBACrB,GAAG;oBACH,qBAAqB,CAAA;gBAEzB,MAAM,EAAE,GAAG,IAAI,CAAC,UAAU,CAAC,kBAAkB,CACzC,IAAI,CAAC,WAAW,CACnB,CAAA;gBACD,EAAE,CAAC,MAAM,CACL,aAAa,GAAG,GAAG,GAAG,mBAAmB,CAAC,YAAY,EACtD,UAAU,CACb;qBACI,SAAS,CACN,QAAQ;oBACJ,EAAE,CAAC,MAAM,CAAC,qBAAqB,CAAC;oBAChC,GAAG;oBACH,EAAE,CAAC,MAAM,CAAC,qBAAqB,CAAC;oBAChC,GAAG,EACP,KAAK,CACR;qBACA,IAAI,CAAC,oBAAoB,EAAE,qBAAqB,CAAC;qBACjD,SAAS,CAAC,iBAAiB,EAAE,aAAa,EAAE,SAAS,CAAC;qBACtD,UAAU,CACP,aAAa;oBACT,GAAG;oBACH,mBAAmB,CAAC,YAAY,CACvC,CAAA;gBAEL,iDAAiD;gBACjD,IAAI,iBAAiB,CAAC,mBAAmB;oBACrC,iBAAiB,CAAC,mBAAmB,CAAC,EAAE,CAAC,CAAA;gBAE7C,OAAO;oBACH,sBAAsB,EAAE,iBAAiB;oBACzC,OAAO,EAAE,MAAM,EAAE,CAAC,UAAU,EAAE;iBACjC,CAAA;YACL,CAAC;QACL,CAAC,CACJ,CAAA;QAED,OAAO,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAA;IAChC,CAAC;CACJ","file":"RelationCountLoader.js","sourcesContent":["import { ColumnMetadata } from \"../../metadata/ColumnMetadata\"\nimport { DataSource } from \"../../data-source/DataSource\"\nimport { RelationCountAttribute } from \"./RelationCountAttribute\"\nimport { RelationCountLoadResult } from \"./RelationCountLoadResult\"\nimport { QueryRunner } from \"../../query-runner/QueryRunner\"\n\nexport class RelationCountLoader {\n    // -------------------------------------------------------------------------\n    // Constructor\n    // -------------------------------------------------------------------------\n\n    constructor(\n        protected connection: DataSource,\n        protected queryRunner: QueryRunner | undefined,\n        protected relationCountAttributes: RelationCountAttribute[],\n    ) {}\n\n    // -------------------------------------------------------------------------\n    // Public Methods\n    // -------------------------------------------------------------------------\n\n    async load(rawEntities: any[]): Promise<RelationCountLoadResult[]> {\n        const onlyUnique = (value: any, index: number, self: any) => {\n            return self.indexOf(value) === index\n        }\n\n        const promises = this.relationCountAttributes.map(\n            async (relationCountAttr) => {\n                if (relationCountAttr.relation.isOneToMany) {\n                    // example: Post and Category\n                    // loadRelationCountAndMap(\"post.categoryCount\", \"post.categories\")\n                    // we expect it to load array of post ids\n\n                    // todo(dima): fix issues wit multiple primary keys and remove joinColumns[0]\n                    const relation = relationCountAttr.relation // \"category.posts\"\n                    const inverseRelation = relation.inverseRelation! // \"post.category\"\n                    const referenceColumnName =\n                        inverseRelation.joinColumns[0].referencedColumn!\n                            .propertyName // post id\n                    const inverseSideTable =\n                        relation.inverseEntityMetadata.target // Post\n                    const inverseSideTableName =\n                        relation.inverseEntityMetadata.tableName // post\n                    const inverseSideTableAlias =\n                        relationCountAttr.alias || inverseSideTableName // if condition (custom query builder factory) is set then relationIdAttr.alias defined\n                    const inverseSidePropertyName = inverseRelation.propertyName // \"category\" from \"post.category\"\n\n                    let referenceColumnValues = rawEntities\n                        .map(\n                            (rawEntity) =>\n                                rawEntity[\n                                    relationCountAttr.parentAlias +\n                                        \"_\" +\n                                        referenceColumnName\n                                ],\n                        )\n                        .filter((value) => !!value)\n                    referenceColumnValues =\n                        referenceColumnValues.filter(onlyUnique)\n\n                    // ensure we won't perform redundant queries for joined data which was not found in selection\n                    // example: if post.category was not found in db then no need to execute query for category.imageIds\n                    if (referenceColumnValues.length === 0)\n                        return {\n                            relationCountAttribute: relationCountAttr,\n                            results: [],\n                        }\n\n                    // generate query:\n                    // SELECT category.post as parentId, COUNT(*) AS cnt FROM category category WHERE category.post IN (1, 2) GROUP BY category.post\n                    const qb = this.connection.createQueryBuilder(\n                        this.queryRunner,\n                    )\n                    qb.select(\n                        inverseSideTableAlias + \".\" + inverseSidePropertyName,\n                        \"parentId\",\n                    )\n                        .addSelect(\"COUNT(*)\", \"cnt\")\n                        .from(inverseSideTable, inverseSideTableAlias)\n                        .where(\n                            inverseSideTableAlias +\n                                \".\" +\n                                inverseSidePropertyName +\n                                \" IN (:...ids)\",\n                        )\n                        .addGroupBy(\n                            inverseSideTableAlias +\n                                \".\" +\n                                inverseSidePropertyName,\n                        )\n                        .setParameter(\"ids\", referenceColumnValues)\n\n                    // apply condition (custom query builder factory)\n                    if (relationCountAttr.queryBuilderFactory)\n                        relationCountAttr.queryBuilderFactory(qb)\n\n                    return {\n                        relationCountAttribute: relationCountAttr,\n                        results: await qb.getRawMany(),\n                    }\n                } else {\n                    // example: Post and Category\n                    // owner side: loadRelationIdAndMap(\"post.categoryIds\", \"post.categories\")\n                    // inverse side: loadRelationIdAndMap(\"category.postIds\", \"category.posts\")\n                    // we expect it to load array of post ids\n\n                    let joinTableColumnName: string\n                    let inverseJoinColumnName: string\n                    let firstJunctionColumn: ColumnMetadata\n                    let secondJunctionColumn: ColumnMetadata\n\n                    if (relationCountAttr.relation.isOwning) {\n                        // todo fix joinColumns[0] and inverseJoinColumns[0].\n                        joinTableColumnName =\n                            relationCountAttr.relation.joinColumns[0]\n                                .referencedColumn!.databaseName\n                        inverseJoinColumnName =\n                            relationCountAttr.relation.inverseJoinColumns[0]\n                                .referencedColumn!.databaseName\n                        firstJunctionColumn =\n                            relationCountAttr.relation.junctionEntityMetadata!\n                                .columns[0]\n                        secondJunctionColumn =\n                            relationCountAttr.relation.junctionEntityMetadata!\n                                .columns[1]\n                    } else {\n                        joinTableColumnName =\n                            relationCountAttr.relation.inverseRelation!\n                                .inverseJoinColumns[0].referencedColumn!\n                                .databaseName\n                        inverseJoinColumnName =\n                            relationCountAttr.relation.inverseRelation!\n                                .joinColumns[0].referencedColumn!.databaseName\n                        firstJunctionColumn =\n                            relationCountAttr.relation.junctionEntityMetadata!\n                                .columns[1]\n                        secondJunctionColumn =\n                            relationCountAttr.relation.junctionEntityMetadata!\n                                .columns[0]\n                    }\n\n                    let referenceColumnValues = rawEntities\n                        .map(\n                            (rawEntity) =>\n                                rawEntity[\n                                    relationCountAttr.parentAlias +\n                                        \"_\" +\n                                        joinTableColumnName\n                                ],\n                        )\n                        .filter((value) => !!value)\n                    referenceColumnValues =\n                        referenceColumnValues.filter(onlyUnique)\n\n                    // ensure we won't perform redundant queries for joined data which was not found in selection\n                    // example: if post.category was not found in db then no need to execute query for category.imageIds\n                    if (referenceColumnValues.length === 0)\n                        return {\n                            relationCountAttribute: relationCountAttr,\n                            results: [],\n                        }\n\n                    const junctionAlias = relationCountAttr.junctionAlias\n                    const inverseSideTableName =\n                        relationCountAttr.joinInverseSideMetadata.tableName\n                    const inverseSideTableAlias =\n                        relationCountAttr.alias || inverseSideTableName\n                    const junctionTableName =\n                        relationCountAttr.relation.junctionEntityMetadata!\n                            .tableName\n\n                    const condition =\n                        junctionAlias +\n                        \".\" +\n                        firstJunctionColumn.propertyName +\n                        \" IN (\" +\n                        referenceColumnValues.map((vals) =>\n                            isNaN(vals) ? \"'\" + vals + \"'\" : vals,\n                        ) +\n                        \")\" +\n                        \" AND \" +\n                        junctionAlias +\n                        \".\" +\n                        secondJunctionColumn.propertyName +\n                        \" = \" +\n                        inverseSideTableAlias +\n                        \".\" +\n                        inverseJoinColumnName\n\n                    const qb = this.connection.createQueryBuilder(\n                        this.queryRunner,\n                    )\n                    qb.select(\n                        junctionAlias + \".\" + firstJunctionColumn.propertyName,\n                        \"parentId\",\n                    )\n                        .addSelect(\n                            \"COUNT(\" +\n                                qb.escape(inverseSideTableAlias) +\n                                \".\" +\n                                qb.escape(inverseJoinColumnName) +\n                                \")\",\n                            \"cnt\",\n                        )\n                        .from(inverseSideTableName, inverseSideTableAlias)\n                        .innerJoin(junctionTableName, junctionAlias, condition)\n                        .addGroupBy(\n                            junctionAlias +\n                                \".\" +\n                                firstJunctionColumn.propertyName,\n                        )\n\n                    // apply condition (custom query builder factory)\n                    if (relationCountAttr.queryBuilderFactory)\n                        relationCountAttr.queryBuilderFactory(qb)\n\n                    return {\n                        relationCountAttribute: relationCountAttr,\n                        results: await qb.getRawMany(),\n                    }\n                }\n            },\n        )\n\n        return Promise.all(promises)\n    }\n}\n"],"sourceRoot":"../.."}

package/browser/query-builder/relation-count/RelationCountMetadataToAttributeTransformer.d.ts

@@ -0,0 +1,7 @@
+import { QueryExpressionMap } from "../QueryExpressionMap";
+export declare class RelationCountMetadataToAttributeTransformer {
+    protected expressionMap: QueryExpressionMap;
+    constructor(expressionMap: QueryExpressionMap);
+    transform(): void;
+    private metadataToAttribute;
+}

package/browser/query-builder/relation-count/RelationCountMetadataToAttributeTransformer.js

@@ -0,0 +1,51 @@
+import { RelationCountAttribute } from "./RelationCountAttribute";
+export 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(this.expressionMap, {
+            relationName: parentAliasName + "." + relationCount.relation.propertyName, // category.images
+            mapToProperty: parentAliasName + "." + relationCount.propertyName, // category.imageIds
+            alias: relationCount.alias,
+            queryBuilderFactory: relationCount.queryBuilderFactory,
+        });
+    }
+}
+
+//# sourceMappingURL=RelationCountMetadataToAttributeTransformer.js.map

package/browser/query-builder/relation-count/RelationCountMetadataToAttributeTransformer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../browser/src/query-builder/relation-count/RelationCountMetadataToAttributeTransformer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAA;AAEjE,MAAM,OAAO,2CAA2C;IACpD,4EAA4E;IAC5E,cAAc;IACd,4EAA4E;IAE5E,YAAsB,aAAiC;QAAjC,kBAAa,GAAb,aAAa,CAAoB;IAAG,CAAC;IAE3D,4EAA4E;IAC5E,iBAAiB;IACjB,4EAA4E;IAE5E,SAAS;QACL,cAAc;QACd,2BAA2B;QAC3B,wDAAwD;QACxD,8BAA8B;QAC9B,yDAAyD;QACzD,iCAAiC;QACjC,oFAAoF;QAEpF,0HAA0H;QAC1H,IAAI,IAAI,CAAC,aAAa,CAAC,SAAS,EAAE,CAAC;YAC/B,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,QAAQ,CAAC,cAAc,CAAC,OAAO,CACxD,CAAC,aAAa,EAAE,EAAE;gBACd,MAAM,SAAS,GAAG,IAAI,CAAC,mBAAmB,CACtC,IAAI,CAAC,aAAa,CAAC,SAAU,CAAC,IAAI,EAClC,aAAa,CAChB,CAAA;gBACD,IAAI,CAAC,aAAa,CAAC,uBAAuB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;YAC9D,CAAC,CACJ,CAAA;QACL,CAAC;QAED,yHAAyH;QACzH,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;YAC/C,8FAA8F;YAC9F,IAAI,CAAC,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,QAAQ,CAAC,UAAU;gBAAE,OAAM;YAEtD,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,aAAa,EAAE,EAAE;gBACnD,MAAM,SAAS,GAAG,IAAI,CAAC,mBAAmB,CACtC,IAAI,CAAC,KAAK,CAAC,IAAI,EACf,aAAa,CAChB,CAAA;gBACD,IAAI,CAAC,aAAa,CAAC,uBAAuB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;YAC9D,CAAC,CAAC,CAAA;QACN,CAAC,CAAC,CAAA;IACN,CAAC;IAED,4EAA4E;IAC5E,kBAAkB;IAClB,4EAA4E;IAEpE,mBAAmB,CACvB,eAAuB,EACvB,aAAoC;QAEpC,OAAO,IAAI,sBAAsB,CAAC,IAAI,CAAC,aAAa,EAAE;YAClD,YAAY,EACR,eAAe,GAAG,GAAG,GAAG,aAAa,CAAC,QAAQ,CAAC,YAAY,EAAE,kBAAkB;YACnF,aAAa,EAAE,eAAe,GAAG,GAAG,GAAG,aAAa,CAAC,YAAY,EAAE,oBAAoB;YACvF,KAAK,EAAE,aAAa,CAAC,KAAK;YAC1B,mBAAmB,EAAE,aAAa,CAAC,mBAAmB;SACzD,CAAC,CAAA;IACN,CAAC;CACJ","file":"RelationCountMetadataToAttributeTransformer.js","sourcesContent":["import { QueryExpressionMap } from \"../QueryExpressionMap\"\nimport { RelationCountMetadata } from \"../../metadata/RelationCountMetadata\"\nimport { RelationCountAttribute } from \"./RelationCountAttribute\"\n\nexport class RelationCountMetadataToAttributeTransformer {\n    // -------------------------------------------------------------------------\n    // Constructor\n    // -------------------------------------------------------------------------\n\n    constructor(protected expressionMap: QueryExpressionMap) {}\n\n    // -------------------------------------------------------------------------\n    // Public Methods\n    // -------------------------------------------------------------------------\n\n    transform() {\n        // by example:\n        // post has relation count:\n        // @RelationCount(post => post.categories) categoryCount\n        // category has relation count\n        // @RelationCount(category => category.images) imageCount\n        // we load post and join category\n        // we expect post.categoryCount and post.category.imageCount to have relation counts\n\n        // first create relation count attributes for all relation count metadatas of the main selected object (post from example)\n        if (this.expressionMap.mainAlias) {\n            this.expressionMap.mainAlias.metadata.relationCounts.forEach(\n                (relationCount) => {\n                    const attribute = this.metadataToAttribute(\n                        this.expressionMap.mainAlias!.name,\n                        relationCount,\n                    )\n                    this.expressionMap.relationCountAttributes.push(attribute)\n                },\n            )\n        }\n\n        // second create relation count attributes for all relation count metadatas of all joined objects (category from example)\n        this.expressionMap.joinAttributes.forEach((join) => {\n            // ensure this join has a metadata, because relation count can only work for real orm entities\n            if (!join.metadata || join.metadata.isJunction) return\n\n            join.metadata.relationCounts.forEach((relationCount) => {\n                const attribute = this.metadataToAttribute(\n                    join.alias.name,\n                    relationCount,\n                )\n                this.expressionMap.relationCountAttributes.push(attribute)\n            })\n        })\n    }\n\n    // -------------------------------------------------------------------------\n    // Private Methods\n    // -------------------------------------------------------------------------\n\n    private metadataToAttribute(\n        parentAliasName: string,\n        relationCount: RelationCountMetadata,\n    ): RelationCountAttribute {\n        return new RelationCountAttribute(this.expressionMap, {\n            relationName:\n                parentAliasName + \".\" + relationCount.relation.propertyName, // category.images\n            mapToProperty: parentAliasName + \".\" + relationCount.propertyName, // category.imageIds\n            alias: relationCount.alias,\n            queryBuilderFactory: relationCount.queryBuilderFactory,\n        })\n    }\n}\n"],"sourceRoot":"../.."}

package/browser/query-builder/relation-id/RelationIdAttribute.d.ts

@@ -0,0 +1,64 @@
+import { RelationMetadata } from "../../metadata/RelationMetadata";
+import { EntityMetadata } from "../../metadata/EntityMetadata";
+import { QueryExpressionMap } from "../QueryExpressionMap";
+import { SelectQueryBuilder } from "../SelectQueryBuilder";
+/**
+ * Stores all join relation id attributes which will be used to build a JOIN query.
+ */
+export declare class RelationIdAttribute {
+    private queryExpressionMap;
+    /**
+     * Alias of the joined (destination) table.
+     */
+    alias?: string;
+    /**
+     * Name of relation.
+     */
+    relationName: string;
+    /**
+     * Property + alias of the object where to joined data should be mapped.
+     */
+    mapToProperty: string;
+    /**
+     * Extra condition applied to "ON" section of join.
+     */
+    queryBuilderFactory?: (qb: SelectQueryBuilder<any>) => SelectQueryBuilder<any>;
+    /**
+     * Indicates if relation id should NOT be loaded as id map.
+     */
+    disableMixedMap: boolean;
+    constructor(queryExpressionMap: QueryExpressionMap, relationIdAttribute?: Partial<RelationIdAttribute>);
+    get joinInverseSideMetadata(): EntityMetadata;
+    /**
+     * 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(): string;
+    /**
+     * 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(): string;
+    /**
+     * 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(): RelationMetadata;
+    /**
+     * Generates alias of junction table, whose ids we get.
+     */
+    get junctionAlias(): string;
+    /**
+     * Metadata of the joined entity.
+     * If extra condition without entity was joined, then it will return undefined.
+     */
+    get junctionMetadata(): EntityMetadata;
+    get mapToPropertyParentAlias(): string;
+    get mapToPropertyPropertyPath(): string;
+}

package/browser/query-builder/relation-id/RelationIdAttribute.js

@@ -0,0 +1,84 @@
+import { QueryBuilderUtils } from "../QueryBuilderUtils";
+import { ObjectUtils } from "../../util/ObjectUtils";
+import { TypeORMError } from "../../error/TypeORMError";
+/**
+ * Stores all join relation id attributes which will be used to build a JOIN query.
+ */
+export class RelationIdAttribute {
+    // -------------------------------------------------------------------------
+    // Constructor
+    // -------------------------------------------------------------------------
+    constructor(queryExpressionMap, relationIdAttribute) {
+        this.queryExpressionMap = queryExpressionMap;
+        /**
+         * Indicates if relation id should NOT be loaded as id map.
+         */
+        this.disableMixedMap = false;
+        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.isAliasProperty(this.relationName))
+            throw new 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.isAliasProperty(this.relationName))
+            throw new 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.isAliasProperty(this.relationName))
+            throw new 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(`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);
+    }
+}
+
+//# sourceMappingURL=RelationIdAttribute.js.map

package/browser/query-builder/relation-id/RelationIdAttribute.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../browser/src/query-builder/relation-id/RelationIdAttribute.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AAIxD,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAEvD;;GAEG;AACH,MAAM,OAAO,mBAAmB;IAgC5B,4EAA4E;IAC5E,cAAc;IACd,4EAA4E;IAE5E,YACY,kBAAsC,EAC9C,mBAAkD;QAD1C,uBAAkB,GAAlB,kBAAkB,CAAoB;QAVlD;;WAEG;QACH,oBAAe,GAAG,KAAK,CAAA;QAUnB,WAAW,CAAC,MAAM,CAAC,IAAI,EAAE,mBAAmB,IAAI,EAAE,CAAC,CAAA;IACvD,CAAC;IAED,4EAA4E;IAC5E,iBAAiB;IACjB,4EAA4E;IAE5E,IAAI,uBAAuB;QACvB,OAAO,IAAI,CAAC,QAAQ,CAAC,qBAAqB,CAAA;IAC9C,CAAC;IAED;;;;;OAKG;IACH,IAAI,WAAW;QACX,IAAI,CAAC,iBAAiB,CAAC,eAAe,CAAC,IAAI,CAAC,YAAY,CAAC;YACrD,MAAM,IAAI,YAAY,CAClB,+DAA+D,CAClE,CAAA;QAEL,OAAO,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAA;IACtE,CAAC;IAED;;;;;;OAMG;IACH,IAAI,oBAAoB;QACpB,IAAI,CAAC,iBAAiB,CAAC,eAAe,CAAC,IAAI,CAAC,YAAY,CAAC;YACrD,MAAM,IAAI,YAAY,CAClB,+DAA+D,CAClE,CAAA;QAEL,OAAO,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAA;IACvE,CAAC;IAED;;;;OAIG;IACH,IAAI,QAAQ;QACR,IAAI,CAAC,iBAAiB,CAAC,eAAe,CAAC,IAAI,CAAC,YAAY,CAAC;YACrD,MAAM,IAAI,YAAY,CAClB,+DAA+D,CAClE,CAAA;QAEL,MAAM,sBAAsB,GAAG,IAAI,CAAC,kBAAkB,CAAC,eAAe,CAClE,IAAI,CAAC,WAAY,CACpB,CAAA;QACD,MAAM,QAAQ,GACV,sBAAsB,CAAC,QAAQ,CAAC,4BAA4B,CACxD,IAAI,CAAC,oBAAqB,CAC7B,CAAA;QACL,IAAI,CAAC,QAAQ;YACT,MAAM,IAAI,YAAY,CAClB,+BAA+B,IAAI,CAAC,oBAAoB,2BAA2B,CACtF,CAAA;QACL,OAAO,QAAQ,CAAA;IACnB,CAAC;IAED;;OAEG;IACH,IAAI,aAAa;QACb,MAAM,CAAC,WAAW,EAAE,gBAAgB,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;QACpE,OAAO,WAAW,GAAG,GAAG,GAAG,gBAAgB,GAAG,MAAM,CAAA;IACxD,CAAC;IAED;;;OAGG;IACH,IAAI,gBAAgB;QAChB,OAAO,IAAI,CAAC,QAAQ,CAAC,sBAAuB,CAAA;IAChD,CAAC;IAED,IAAI,wBAAwB;QACxB,OAAO,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAA;IACxE,CAAC;IAED,IAAI,yBAAyB;QACzB,OAAO,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAA;IACzE,CAAC;CACJ","file":"RelationIdAttribute.js","sourcesContent":["import { RelationMetadata } from \"../../metadata/RelationMetadata\"\nimport { QueryBuilderUtils } from \"../QueryBuilderUtils\"\nimport { EntityMetadata } from \"../../metadata/EntityMetadata\"\nimport { QueryExpressionMap } from \"../QueryExpressionMap\"\nimport { SelectQueryBuilder } from \"../SelectQueryBuilder\"\nimport { ObjectUtils } from \"../../util/ObjectUtils\"\nimport { TypeORMError } from \"../../error/TypeORMError\"\n\n/**\n * Stores all join relation id attributes which will be used to build a JOIN query.\n */\nexport class RelationIdAttribute {\n    // -------------------------------------------------------------------------\n    // Public Properties\n    // -------------------------------------------------------------------------\n\n    /**\n     * Alias of the joined (destination) table.\n     */\n    alias?: string\n\n    /**\n     * Name of relation.\n     */\n    relationName: string\n\n    /**\n     * Property + alias of the object where to joined data should be mapped.\n     */\n    mapToProperty: string\n\n    /**\n     * Extra condition applied to \"ON\" section of join.\n     */\n    queryBuilderFactory?: (\n        qb: SelectQueryBuilder<any>,\n    ) => SelectQueryBuilder<any>\n\n    /**\n     * Indicates if relation id should NOT be loaded as id map.\n     */\n    disableMixedMap = false\n\n    // -------------------------------------------------------------------------\n    // Constructor\n    // -------------------------------------------------------------------------\n\n    constructor(\n        private queryExpressionMap: QueryExpressionMap,\n        relationIdAttribute?: Partial<RelationIdAttribute>,\n    ) {\n        ObjectUtils.assign(this, relationIdAttribute || {})\n    }\n\n    // -------------------------------------------------------------------------\n    // Public Methods\n    // -------------------------------------------------------------------------\n\n    get joinInverseSideMetadata(): EntityMetadata {\n        return this.relation.inverseEntityMetadata\n    }\n\n    /**\n     * Alias of the parent of this join.\n     * For example, if we join (\"post.category\", \"categoryAlias\") then \"post\" is a parent alias.\n     * This value is extracted from entityOrProperty value.\n     * This is available when join was made using \"post.category\" syntax.\n     */\n    get parentAlias(): string {\n        if (!QueryBuilderUtils.isAliasProperty(this.relationName))\n            throw new TypeORMError(\n                `Given value must be a string representation of alias property`,\n            )\n\n        return this.relationName.substr(0, this.relationName.indexOf(\".\"))\n    }\n\n    /**\n     * Relation property name of the parent.\n     * This is used to understand what is joined.\n     * For example, if we join (\"post.category\", \"categoryAlias\") then \"category\" is a relation property.\n     * This value is extracted from entityOrProperty value.\n     * This is available when join was made using \"post.category\" syntax.\n     */\n    get relationPropertyPath(): string {\n        if (!QueryBuilderUtils.isAliasProperty(this.relationName))\n            throw new TypeORMError(\n                `Given value must be a string representation of alias property`,\n            )\n\n        return this.relationName.substr(this.relationName.indexOf(\".\") + 1)\n    }\n\n    /**\n     * Relation of the parent.\n     * This is used to understand what is joined.\n     * This is available when join was made using \"post.category\" syntax.\n     */\n    get relation(): RelationMetadata {\n        if (!QueryBuilderUtils.isAliasProperty(this.relationName))\n            throw new TypeORMError(\n                `Given value must be a string representation of alias property`,\n            )\n\n        const relationOwnerSelection = this.queryExpressionMap.findAliasByName(\n            this.parentAlias!,\n        )\n        const relation =\n            relationOwnerSelection.metadata.findRelationWithPropertyPath(\n                this.relationPropertyPath!,\n            )\n        if (!relation)\n            throw new TypeORMError(\n                `Relation with property path ${this.relationPropertyPath} in entity was not found.`,\n            )\n        return relation\n    }\n\n    /**\n     * Generates alias of junction table, whose ids we get.\n     */\n    get junctionAlias(): string {\n        const [parentAlias, relationProperty] = this.relationName.split(\".\")\n        return parentAlias + \"_\" + relationProperty + \"_rid\"\n    }\n\n    /**\n     * Metadata of the joined entity.\n     * If extra condition without entity was joined, then it will return undefined.\n     */\n    get junctionMetadata(): EntityMetadata {\n        return this.relation.junctionEntityMetadata!\n    }\n\n    get mapToPropertyParentAlias(): string {\n        return this.mapToProperty.substr(0, this.mapToProperty.indexOf(\".\"))\n    }\n\n    get mapToPropertyPropertyPath(): string {\n        return this.mapToProperty.substr(this.mapToProperty.indexOf(\".\") + 1)\n    }\n}\n"],"sourceRoot":"../.."}

package/browser/query-builder/relation-id/RelationIdLoadResult.d.ts

@@ -0,0 +1,5 @@
+import { RelationIdAttribute } from "./RelationIdAttribute";
+export interface RelationIdLoadResult {
+    relationIdAttribute: RelationIdAttribute;
+    results: any[];
+}

package/browser/query-builder/relation-id/RelationIdLoadResult.js

@@ -0,0 +1,3 @@
+export {};
+
+//# sourceMappingURL=RelationIdLoadResult.js.map

package/browser/query-builder/relation-id/RelationIdLoadResult.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../browser/src/query-builder/relation-id/RelationIdLoadResult.ts"],"names":[],"mappings":"","file":"RelationIdLoadResult.js","sourcesContent":["import { RelationIdAttribute } from \"./RelationIdAttribute\"\n\nexport interface RelationIdLoadResult {\n    relationIdAttribute: RelationIdAttribute\n    results: any[]\n}\n"],"sourceRoot":"../.."}

package/browser/query-builder/relation-id/RelationIdLoader.d.ts

@@ -0,0 +1,11 @@
+import { RelationIdAttribute } from "./RelationIdAttribute";
+import { DataSource } from "../../data-source/DataSource";
+import { RelationIdLoadResult } from "./RelationIdLoadResult";
+import { QueryRunner } from "../../query-runner/QueryRunner";
+export declare class RelationIdLoader {
+    protected connection: DataSource;
+    protected queryRunner: QueryRunner | undefined;
+    protected relationIdAttributes: RelationIdAttribute[];
+    constructor(connection: DataSource, queryRunner: QueryRunner | undefined, relationIdAttributes: RelationIdAttribute[]);
+    load(rawEntities: any[]): Promise<RelationIdLoadResult[]>;
+}