Function buildCountJson

packages/orm/src/client/crud/dialects/base-dialect.ts:1473–1529

(model: string, eb: ExpressionBuilder<any, any>, parentAlias: string, payload: any)

    }

    buildCountJson(model: string, eb: ExpressionBuilder<any, any>, parentAlias: string, payload: any) {
        const modelDef = requireModel(this.schema, model);
        const toManyRelations = Object.entries(modelDef.fields).filter(([, field]) => field.relation && field.array);

        const selections =
            payload === true
                ? {
                      select: toManyRelations.reduce(
                          (acc, [field]) => {
                              acc[field] = true;
                              return acc;
                          },
                          {} as Record<string, boolean>,
                      ),
                  }
                : payload;

        const jsonObject: Record<string, Expression<any>> = {};

        for (const [field, value] of Object.entries(selections.select)) {
            const fieldDef = requireField(this.schema, model, field);
            const fieldModel = fieldDef.type as GetModels<Schema>;
            let fieldCountQuery: SelectQueryBuilder<any, any, any>;

            // Use a unique alias for the subquery to avoid ambiguous references when
            // fieldModel === model (self-referential relation on a delegate model)
            const subQueryAlias = tmpAlias(`${parentAlias}$_${field}$count`);

            // join conditions
            const m2m = getManyToManyRelation(this.schema, model, field);
            if (m2m) {
                // many-to-many relation, count the join table
                fieldCountQuery = this.buildModelSelect(fieldModel, subQueryAlias, value as any, false)
                    .innerJoin(m2m.joinTable, (join) =>
                        join
                            .onRef(`${m2m.joinTable}.${m2m.otherFkName}`, '=', `${subQueryAlias}.${m2m.otherPKName}`)
                            .onRef(`${m2m.joinTable}.${m2m.parentFkName}`, '=', `${parentAlias}.${m2m.parentPKName}`),
                    )
                    .select(eb.fn.countAll().as(`_count$${field}`));
            } else {
                // build a nested query to count the number of records in the relation
                fieldCountQuery = this.buildModelSelect(fieldModel, subQueryAlias, value as any, false).select(
                    eb.fn.countAll().as(`_count$${field}`),
                );

                // join conditions
                const joinPairs = buildJoinPairs(this.schema, model, parentAlias, field, subQueryAlias);
                for (const [left, right] of joinPairs) {
                    fieldCountQuery = fieldCountQuery.whereRef(left, '=', right);
                }
            }

            jsonObject[field] = fieldCountQuery;
        }

        return this.buildJsonObject(jsonObject);
    }