Merge branch 'main' into dependabot/npm_and_yarn/globals-17.4.0

graduta · web-flow · commit 4202798c6e4d · 2026-03-05T15:26:53.000+01:00
diff --git a/lib/usecases/environment/GetAllEnvironmentsUseCase.js b/lib/usecases/environment/GetAllEnvironmentsUseCase.js
@@ -23,6 +23,7 @@ const { dataSource } = require('../../database/DataSource.js');
 const { statusAcronyms } = require('../../domain/enums/StatusAcronyms.js');
 const { unpackNumberRange } = require('../../utilities/rangeUtils.js');
 const { splitStringToStringsTrimmed } = require('../../utilities/stringUtils.js');
+const { setTimeRangeQuery } = require('../../utilities/setTimeRangeQuery.js');
 
 /**
  * Subquery to select the latest history item for each environment.
@@ -69,18 +70,11 @@ class GetAllEnvironmentsUseCase {
         const { filter, page = {} } = query;
         const { limit = ApiConfig.pagination.limit, offset = 0 } = page;
 
-        /**
-         * Prepare a query builder with ordering, limit and offset
-         *
-         * @return {QueryBuilder} the created query builder
-         */
-        const prepareQueryBuilder = () => dataSource.createQueryBuilder()
+        const queryBuilder = dataSource.createQueryBuilder()
             .orderBy('updatedAt', 'desc')
             .limit(limit)
             .offset(offset);
 
-        const fetchQueryBuilder = prepareQueryBuilder();
-
         if (filter) {
             const {
                 ids: idsExpression,
@@ -90,38 +84,34 @@ class GetAllEnvironmentsUseCase {
                 created,
             } = filter;
 
-            const filterQueryBuilder = prepareQueryBuilder();
-
             if (created) {
-                const from = created.from !== undefined ? created.from : 0;
-                const to = created.to !== undefined ? created.to : Date.now();
-                filterQueryBuilder.where('createdAt').between(from, to);
+                setTimeRangeQuery(created, 'createdAt', queryBuilder);
             }
 
             if (idsExpression) {
                 const filters = idsExpression.split(',').map((id) => id.trim());
 
                 // Filter should be like with only one filter
                 if (filters.length === 1) {
-                    filterQueryBuilder.where('id').substring(filters[0]);
+                    queryBuilder.where('id').substring(filters[0]);
                 }
 
                 // Filters should be exact with more than one filter
                 if (filters.length > 1) {
-                    filterQueryBuilder.andWhere({ id: { [Op.in]: filters } });
+                    queryBuilder.andWhere({ id: { [Op.in]: filters } });
                 }
             }
 
             if (currentStatusExpression) {
                 const filters = currentStatusExpression.split(',').map((status) => status.trim());
 
                 // Filter the environments by current status using the subquery
-                filterQueryBuilder.literalWhere(
+                queryBuilder.literalWhere(
                     `${ENVIRONMENT_LATEST_HISTORY_ITEM_SUBQUERY} IN (:filters)`,
                     { filters },
                 );
 
-                filterQueryBuilder.includeAttribute({
+                queryBuilder.includeAttribute({
                     query: ENVIRONMENT_LATEST_HISTORY_ITEM_SUBQUERY,
                     alias: 'currentStatus',
                 });
@@ -157,7 +147,7 @@ class GetAllEnvironmentsUseCase {
                      * Use OR condition to match subsequences ending with either DESTROYED or DONE
                      * Filter the environments by using LIKE for subsequence matching
                      */
-                    filterQueryBuilder.literalWhere(
+                    queryBuilder.literalWhere(
                         `(${ENVIRONMENT_STATUS_HISTORY_SUBQUERY} LIKE :statusFiltersWithDestroyed OR ` +
                         `${ENVIRONMENT_STATUS_HISTORY_SUBQUERY} LIKE :statusFiltersWithDone)`,
                         {
@@ -166,17 +156,17 @@ class GetAllEnvironmentsUseCase {
                         },
                     );
 
-                    filterQueryBuilder.includeAttribute({
+                    queryBuilder.includeAttribute({
                         query: ENVIRONMENT_STATUS_HISTORY_SUBQUERY,
                         alias: 'statusHistory',
                     });
                 } else {
-                    filterQueryBuilder.literalWhere(
+                    queryBuilder.literalWhere(
                         `${ENVIRONMENT_STATUS_HISTORY_SUBQUERY} LIKE :statusFilters`,
                         { statusFilters: `%${statusFilters.join(',')}%` },
                     );
 
-                    filterQueryBuilder.includeAttribute({
+                    queryBuilder.includeAttribute({
                         query: ENVIRONMENT_STATUS_HISTORY_SUBQUERY,
                         alias: 'statusHistory',
                     });
@@ -190,30 +180,20 @@ class GetAllEnvironmentsUseCase {
 
                 // Check that the final run numbers list contains at least one valid run number
                 if (finalRunNumberList.length > 0) {
-                    filterQueryBuilder.include({
+                    queryBuilder.include({
                         association: 'runs',
                         where: {
                             // Filter should be like with only one filter and exact with more than one filter
                             runNumber: { [finalRunNumberList.length === 1 ? Op.substring : Op.in]: finalRunNumberList },
                         },
                     });
                 }
-            };
-
-            const filteredEnvironmentsIds = (await EnvironmentRepository.findAll(filterQueryBuilder)).map(({ id }) => id);
-            // If no environments match the filter, return an empty result
-            if (filteredEnvironmentsIds.length === 0) {
-                return {
-                    count: 0,
-                    environments: [],
-                };
             }
-            fetchQueryBuilder.where('id').oneOf(filteredEnvironmentsIds);
         }
 
-        fetchQueryBuilder.include({ association: 'runs' });
-        fetchQueryBuilder.include({ association: 'historyItems' });
-        const { count, rows } = await EnvironmentRepository.findAndCountAll(fetchQueryBuilder);
+        queryBuilder.include({ association: 'runs' });
+        queryBuilder.include({ association: 'historyItems' });
+        const { count, rows } = await EnvironmentRepository.findAndCountAll(queryBuilder);
         return {
             count,
             environments: rows.map((environment) => environmentAdapter.toEntity(environment)),
diff --git a/lib/usecases/lhcFill/GetAllLhcFillsUseCase.js b/lib/usecases/lhcFill/GetAllLhcFillsUseCase.js
@@ -24,6 +24,7 @@ const { ApiConfig } = require('../../config/index.js');
 const { RunDefinition } = require('../../domain/enums/RunDefinition.js');
 const { unpackNumberRange } = require('../../utilities/rangeUtils.js');
 const { splitStringToStringsTrimmed } = require('../../utilities/stringUtils.js');
+const { setTimeRangeQuery } = require('../../utilities/setTimeRangeQuery.js');
 
 /**
  * GetAllLhcFillsUseCase
@@ -54,15 +55,11 @@ class GetAllLhcFillsUseCase {
             }
 
             if (stableBeamsStart) {
-                const from = stableBeamsStart.from !== undefined ? stableBeamsStart.from : 0;
-                const to = stableBeamsStart.to !== undefined ? stableBeamsStart.to : new Date().getTime();
-                queryBuilder.where('stableBeamsStart').between(from, to);
+                setTimeRangeQuery(stableBeamsStart, 'stableBeamsStart', queryBuilder);
             }
 
             if (stableBeamsEnd) {
-                const from = stableBeamsEnd.from !== undefined ? stableBeamsEnd.from : 0;
-                const to = stableBeamsEnd.to !== undefined ? stableBeamsEnd.to : new Date().getTime();
-                queryBuilder.where('stableBeamsEnd').between(from, to);
+                setTimeRangeQuery(stableBeamsEnd, 'stableBeamsEnd', queryBuilder);
             }
 
             if (fillNumbers) {
diff --git a/lib/usecases/log/GetAllLogsUseCase.js b/lib/usecases/log/GetAllLogsUseCase.js
@@ -29,6 +29,7 @@ const { ApiConfig } = require('../../config/index.js');
 const { Op } = require('sequelize');
 const { dataSource } = require('../../database/DataSource.js');
 const { checkForFilterExclusion } = require('../common/checkForFilterExclusion.js');
+const { setTimeRangeQuery } = require('../../utilities/setTimeRangeQuery.js');
 
 /**
  * Apply the given filter on the given query builder
@@ -73,9 +74,7 @@ const applyFilter = async (dataSource, queryBuilder, filter) => {
     }
 
     if (created) {
-        const from = created.from !== undefined ? created.from : 0;
-        const to = created.to !== undefined ? created.to : new Date().getTime();
-        queryBuilder.where('createdAt').between(from, to);
+        setTimeRangeQuery(created, 'createdAt', queryBuilder);
     }
 
     if (origin) {
diff --git a/lib/usecases/run/GetAllRunsUseCase.js b/lib/usecases/run/GetAllRunsUseCase.js
@@ -25,6 +25,7 @@ const { qcFlagSummaryService } = require('../../server/services/qualityControlFl
 const { DetectorType } = require('../../domain/enums/DetectorTypes.js');
 const { unpackNumberRange } = require('../../utilities/rangeUtils.js');
 const { splitStringToStringsTrimmed } = require('../../utilities/stringUtils.js');
+const { setTimeRangeQuery } = require('../../utilities/setTimeRangeQuery.js');
 
 /**
  * GetAllRunsUseCase
@@ -151,21 +152,15 @@ class GetAllRunsUseCase {
             }
 
             if (o2start) {
-                const from = o2start.from !== undefined ? o2start.from : 0;
-                const to = o2start.to !== undefined ? o2start.to : new Date().getTime();
-                filteringQueryBuilder.where('timeO2Start').between(from, to);
+                setTimeRangeQuery(o2start, 'timeO2Start', filteringQueryBuilder);
             }
 
             if (o2end) {
-                const from = o2end.from !== undefined ? o2end.from : 0;
-                const to = o2end.to !== undefined ? o2end.to : new Date().getTime();
-                filteringQueryBuilder.where('timeO2End').between(from, to);
+                setTimeRangeQuery(o2end, 'timeO2End', filteringQueryBuilder);
             }
 
             if (updatedAt) {
-                const from = updatedAt.from ?? 0;
-                const to = updatedAt.to ?? new Date().getTime();
-                filteringQueryBuilder.where('updatedAt').between(from, to);
+                setTimeRangeQuery(updatedAt, 'updatedAt', filteringQueryBuilder);
             }
 
             if (triggerValues) {
diff --git a/lib/utilities/setTimeRangeQuery.js b/lib/utilities/setTimeRangeQuery.js
@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright CERN and copyright holders of ALICE O2. This software is
+ * distributed under the terms of the GNU General Public License v3 (GPL
+ * Version 3), copied verbatim in the file "COPYING".
+ *
+ * See http://alice-o2.web.cern.ch/license for full licensing information.
+ *
+ * In applying this license CERN does not waive the privileges and immunities
+ * granted to it by virtue of its status as an Intergovernmental Organization
+ * or submit itself to any jurisdiction.
+ */
+
+/**
+ * Function that sets a time range in a QueryBuilder.
+ *
+ * @param {object} timerange an object that defines a time range to add to the query
+ * @param {number} timerange.from the lower bound of the time range
+ * @param {number} timerange.to the upper bound of the time range
+ * @param {string} attribute the model attribute for which the range will be set
+ * @param {QueryBuilder} queryBuilder queryBuider instance in which the time range will be set.
+ * @returns {void}
+ */
+exports.setTimeRangeQuery = ({ from = 0, to = Date.now() }, attribute, queryBuilder) =>
+    queryBuilder.where(attribute).between(from, to);
diff --git a/test/lib/usecases/environment/GetAllEnvironmentsUseCase.test.js b/test/lib/usecases/environment/GetAllEnvironmentsUseCase.test.js
@@ -225,4 +225,40 @@ module.exports = () => {
         expect(environments).to.be.an('array');
         expect(environments.length).to.be.equal(0); // Environments from seeders
     });
+
+    it('should return correct total count and all filtered results across pages', async () => {
+        const totalMatchingFilter = 6; // 'RUNNING, ERROR' matches 6 environments at this point
+        const limit = 2;
+
+        // First page
+        getAllEnvsDto.query = { page: { limit, offset: 0 }, filter: { currentStatus: 'RUNNING, ERROR' } };
+        const page1 = await new GetAllEnvironmentsUseCase().execute(getAllEnvsDto);
+
+        expect(page1.count).to.be.equal(totalMatchingFilter);
+        expect(page1.environments).to.be.an('array');
+        expect(page1.environments.length).to.be.equal(limit);
+
+        // Second page
+        getAllEnvsDto.query = { page: { limit, offset: 2 }, filter: { currentStatus: 'RUNNING, ERROR' } };
+        const page2 = await new GetAllEnvironmentsUseCase().execute(getAllEnvsDto);
+
+        expect(page2.count).to.be.equal(totalMatchingFilter);
+        expect(page2.environments).to.be.an('array');
+        expect(page2.environments.length).to.be.equal(limit);
+
+        // Third page
+        getAllEnvsDto.query = { page: { limit, offset: 4 }, filter: { currentStatus: 'RUNNING, ERROR' } };
+        const page3 = await new GetAllEnvironmentsUseCase().execute(getAllEnvsDto);
+
+        expect(page3.count).to.be.equal(totalMatchingFilter);
+        expect(page3.environments).to.be.an('array');
+        expect(page3.environments.length).to.be.equal(limit);
+
+        // Collect all environment IDs and verify no duplicates and all present
+        const allIds = [page1, page2, page3].flatMap(({ environments })=> environments.map(({ id }) => id));
+
+        expect(allIds.length).to.be.equal(totalMatchingFilter);
+        expect(new Set(allIds).size).to.be.equal(totalMatchingFilter);
+        expect(allIds).to.have.members(['SomeId', 'newId', 'CmCvjNbg', 'EIDO13i3D', '8E4aZTjY', 'Dxi029djX']);
+    });
 };
