@studyportals/fawkes 8.7.2-2 → 8.7.2-21

package/dist/sitemap-generator-seo/index.d.ts

@@ -11,3 +11,4 @@ export { ISitemapUrlGenerator } from '../src/common/ISitemapUrlGenerator';
 export { FilterKeyValuesMap } from '../src/common/FilterKeyValuesMap';
 export { IPresenter } from '../src/common';
 export { IProgrammeSitemapUrlGenerator } from '../src/programmes/types/IProgrammeSitemapUrlGenerator';
+export { IRankingApiClient } from '../src/sitemap-generator/IRankingApiClient';

package/dist/src/common/FilterKeyToFilterTypeMap.d.ts

@@ -1,3 +1,2 @@
 import { FilterKey } from '@studyportals/search-filters/server-side';
-import { FilterType } from '@studyportals/omnisearch-interfaces';
 export declare const FILTER_KEY_TO_FILTER_TYPE_MAP: Map<FilterKey, FilterType>;

package/dist/src/common/index.d.ts

@@ -3,4 +3,3 @@ export * from './ISeoFilterState';
 export * from './ISearchApplicationState';
 export * from './ISearchIndexabilityManager';
 export * from './IPresenter';
-export * from './FilterTypeMap';

package/dist/src/common/index.js

@@ -3,4 +3,3 @@ export * from './ISeoFilterState';
 export * from './ISearchApplicationState';
 export * from './ISearchIndexabilityManager';
 export * from './IPresenter';
-export * from './FilterTypeMap';

package/dist/src/organisations/policies/our-picks/AreaAttendance.js

@@ -23,21 +23,23 @@ export class AreaAttendance extends OrganisationsSeoIndexabilityPolicy {
     async generateUrls() {
         const areaFragments = AreaPresenter.getInstance().getFragments();
         const attendanceFragments = AttendancePresenter.getInstance().getFragments();
-        const paths = [];
-        for (const area of areaFragments) {
-            for (const attendance of attendanceFragments) {
-                const filterKeyValues = new Map([
-                    [FilterKey.AREA, [area.id]],
-                    [FilterKey.COUNTRY, [area.countryId]],
-                    [FilterKey.DELIVERY_METHOD, [attendance.id]]
-                ]);
-                const result = await this.checkRulesForSitemap(filterKeyValues);
-                if (result) {
-                    paths.push(this.getPathWithSortingOption(`${attendance.path}/${area.path}`));
-                }
+        // Create array of promises for all combinations to parallelize API calls
+        const promises = areaFragments.flatMap(area => attendanceFragments.map(async (attendance) => {
+            const filterKeyValues = new Map([
+                [FilterKey.AREA, [area.id]],
+                [FilterKey.COUNTRY, [area.countryId]],
+                [FilterKey.DELIVERY_METHOD, [attendance.id]]
+            ]);
+            const result = await this.checkRulesForSitemap(filterKeyValues);
+            if (result) {
+                return this.getPathWithSortingOption(`${attendance.path}/${area.path}`);
             }
-        }
-        return paths;
+            return null;
+        }));
+        // Wait for all promises to resolve in parallel
+        const results = await Promise.all(promises);
+        // Filter out null values and return paths
+        return results.filter((path) => path !== null);
     }
     get filterCombination() {
         return FilterCombinations.AREA_ATTENDANCE;

package/dist/src/organisations/policies/our-picks/CountryAttendance.js

@@ -25,19 +25,21 @@ export class CountryAttendance extends OrganisationsSeoIndexabilityPolicy {
     async generateUrls() {
         const countryFragments = CountryPresenter.getInstance().getFragments();
         const attendanceFragments = AttendancePresenter.getInstance().getFragments();
-        const paths = [];
-        for (const country of countryFragments) {
-            for (const attendance of attendanceFragments) {
-                const filterKeyValues = new Map([
-                    [FilterKey.COUNTRY, [country.id]],
-                    [FilterKey.DELIVERY_METHOD, [attendance.id]]
-                ]);
-                const result = await this.checkRulesForSitemap(filterKeyValues);
-                if (result) {
-                    paths.push(this.getPathWithSortingOption(`${attendance.path}/${country.path}`));
-                }
+        // Create array of promises for all combinations to parallelize API calls
+        const promises = countryFragments.flatMap(country => attendanceFragments.map(async (attendance) => {
+            const filterKeyValues = new Map([
+                [FilterKey.COUNTRY, [country.id]],
+                [FilterKey.DELIVERY_METHOD, [attendance.id]]
+            ]);
+            const result = await this.checkRulesForSitemap(filterKeyValues);
+            if (result) {
+                return this.getPathWithSortingOption(`${attendance.path}/${country.path}`);
             }
-        }
-        return paths;
+            return null;
+        }));
+        // Wait for all promises to resolve in parallel
+        const results = await Promise.all(promises);
+        // Filter out null values and return paths
+        return results.filter((path) => path !== null);
     }
 }

package/dist/src/organisations/policies/ranked/RankedAttendanceDiscipline.js

@@ -24,19 +24,21 @@ export class RankedAttendanceDiscipline extends RankedOrganisationsSeoIndexabili
     async generateUrls() {
         const attendanceFragments = AttendancePresenter.getInstance().getFragments();
         const disciplineFragments = DisciplinePresenter.getInstance().getFragments();
-        const paths = [];
-        for (const attendance of attendanceFragments) {
-            for (const discipline of disciplineFragments) {
-                const filterKeyValues = new Map([
-                    [FilterKey.DELIVERY_METHOD, [attendance.id]],
-                    [FilterKey.DISCIPLINES, [discipline.id]],
-                ]);
-                const result = await this.checkRulesForSitemap(filterKeyValues);
-                if (result) {
-                    paths.push(this.getPathWithSortingOption(`${attendance.path}/${discipline.path}`));
-                }
+        // Create array of promises for all combinations to parallelize API calls
+        const promises = attendanceFragments.flatMap(attendance => disciplineFragments.map(async (discipline) => {
+            const filterKeyValues = new Map([
+                [FilterKey.DELIVERY_METHOD, [attendance.id]],
+                [FilterKey.DISCIPLINES, [discipline.id]],
+            ]);
+            const result = await this.checkRulesForSitemap(filterKeyValues);
+            if (result) {
+                return this.getPathWithSortingOption(`${attendance.path}/${discipline.path}`);
             }
-        }
-        return paths;
+            return null;
+        }));
+        // Wait for all promises to resolve in parallel
+        const results = await Promise.all(promises);
+        // Filter out null values and return paths
+        return results.filter((path) => path !== null);
     }
 }

package/dist/src/organisations/policies/ranked/RankedContinentAttendance.js

@@ -23,20 +23,22 @@ export class RankedContinentAttendance extends RankedOrganisationsSeoIndexabilit
     async generateUrls() {
         const continentFragments = ContinentPresenter.getInstance().getFragments();
         const attendanceFragments = AttendancePresenter.getInstance().getFragments();
-        const paths = [];
-        for (const continent of continentFragments) {
-            for (const attendance of attendanceFragments) {
-                const filterKeyValues = new Map([
-                    [FilterKey.CONTINENT, [continent.id]],
-                    [FilterKey.DELIVERY_METHOD, [attendance.id]],
-                ]);
-                const result = await this.checkRulesForSitemap(filterKeyValues);
-                if (result) {
-                    paths.push(this.getPathWithSortingOption(`${attendance.path}/${continent.path}`));
-                }
+        // Create array of promises for all combinations to parallelize API calls
+        const promises = continentFragments.flatMap(continent => attendanceFragments.map(async (attendance) => {
+            const filterKeyValues = new Map([
+                [FilterKey.CONTINENT, [continent.id]],
+                [FilterKey.DELIVERY_METHOD, [attendance.id]],
+            ]);
+            const result = await this.checkRulesForSitemap(filterKeyValues);
+            if (result) {
+                return this.getPathWithSortingOption(`${attendance.path}/${continent.path}`);
             }
-        }
-        return paths;
+            return null;
+        }));
+        // Wait for all promises to resolve in parallel
+        const results = await Promise.all(promises);
+        // Filter out null values and return paths
+        return results.filter((path) => path !== null);
     }
     get filterCombination() {
         return FilterCombinations.RANKED_CONTINENT_ATTENDANCE;

package/dist/src/organisations/policies/ranked/RankedCountryAttendance.js

@@ -21,20 +21,22 @@ export class RankedCountryAttendance extends RankedOrganisationsSeoIndexabilityP
     async generateUrls() {
         const countryFragments = CountryPresenter.getInstance().getFragments();
         const attendanceFragments = AttendancePresenter.getInstance().getFragments();
-        const paths = [];
-        for (const country of countryFragments) {
-            for (const attendance of attendanceFragments) {
-                const filterKeyValues = new Map([
-                    [FilterKey.COUNTRY, [country.id]],
-                    [FilterKey.DELIVERY_METHOD, [attendance.id]]
-                ]);
-                const result = await this.checkRulesForSitemap(filterKeyValues);
-                if (result) {
-                    paths.push(this.getPathWithSortingOption(`${attendance.path}/${country.path}`));
-                }
+        // Create array of promises for all combinations to parallelize API calls
+        const promises = countryFragments.flatMap(country => attendanceFragments.map(async (attendance) => {
+            const filterKeyValues = new Map([
+                [FilterKey.COUNTRY, [country.id]],
+                [FilterKey.DELIVERY_METHOD, [attendance.id]]
+            ]);
+            const result = await this.checkRulesForSitemap(filterKeyValues);
+            if (result) {
+                return this.getPathWithSortingOption(`${attendance.path}/${country.path}`);
             }
-        }
-        return paths;
+            return null;
+        }));
+        // Wait for all promises to resolve in parallel
+        const results = await Promise.all(promises);
+        // Filter out null values and return paths
+        return results.filter((path) => path !== null);
     }
     get filterCombination() {
         return FilterCombinations.RANKED_COUNTRY_ATTENDANCE;

package/dist/src/organisations/policies/ranked/RankedCountryDiscipline.js

@@ -17,22 +17,30 @@ export class RankedCountryDiscipline extends RankedOrganisationsSeoIndexabilityP
         super(dependencies);
     }
     async generateUrls() {
-        const countryFragments = CountryPresenter.getInstance().getFragments();
-        const disciplineFragments = DisciplinePresenter.getInstance().getFragments();
-        const paths = [];
-        for (const country of countryFragments) {
-            for (const discipline of disciplineFragments) {
+        try {
+            const countryFragments = CountryPresenter.getInstance().getFragments();
+            const disciplineFragments = DisciplinePresenter.getInstance().getFragments();
+            // Create array of promises for all combinations to parallelize API calls
+            const promises = countryFragments.flatMap(country => disciplineFragments.map(async (discipline) => {
                 const filterKeyValues = new Map([
                     [FilterKey.COUNTRY, [country.id]],
-                    [FilterKey.DISCIPLINES, [discipline.id]],
+                    [FilterKey.DISCIPLINES, [discipline.id]]
                 ]);
                 const result = await this.checkRulesForSitemap(filterKeyValues);
                 if (result) {
-                    paths.push(this.getPathWithSortingOption(`${country.path}/${discipline.path}`));
+                    return this.getPathWithSortingOption(`${country.path}/${discipline.path}`);
                 }
-            }
+                return null;
+            }));
+            // Wait for all promises to resolve in parallel
+            const results = await Promise.all(promises);
+            // Filter out null values and return paths
+            return results.filter((path) => path !== null);
+        }
+        catch (error) {
+            console.error('Error generating URLs for RankedCountryDiscipline:', error);
+            return [];
         }
-        return paths;
     }
     get filterCombination() {
         return FilterCombinations.RANKED_DISCIPLINE_COUNTRY;

package/dist/src/organisations/policies/ranked/RankedDiscipline.js

@@ -15,18 +15,22 @@ export class RankedDiscipline extends RankedOrganisationsSeoIndexabilityPolicy {
         super(dependencies);
     }
     async generateUrls() {
-        const disciplineFragments = DisciplinePresenter.getInstance().getFragments();
-        const paths = [];
-        for (const discipline of disciplineFragments) {
-            const filterKeyValues = new Map([
-                [FilterKey.DISCIPLINES, [discipline.id]]
-            ]);
-            const result = await this.checkRulesForSitemap(filterKeyValues);
-            if (result) {
-                paths.push(this.getPathWithSortingOption(discipline.path));
+        try {
+            const disciplineFragments = DisciplinePresenter.getInstance().getFragments();
+            const paths = [];
+            for (const discipline of disciplineFragments) {
+                const filterKeyValues = new Map([[FilterKey.DISCIPLINES, [discipline.id]]]);
+                const result = await this.checkRulesForSitemap(filterKeyValues);
+                if (result) {
+                    paths.push(this.getPathWithSortingOption(discipline.path));
+                }
             }
+            return paths;
+        }
+        catch (error) {
+            console.error('Error generating URLs for RankedDiscipline:', error);
+            return [];
         }
-        return paths;
     }
     get filterCombination() {
         return FilterCombinations.RANKED_DISCIPLINE;

package/dist/src/organisations/policies/ranked/RankedUnfiltered.js

@@ -9,11 +9,17 @@ export class RankedUnfiltered extends RankedOrganisationsSeoIndexabilityPolicy {
         super(dependencies);
     }
     async generateUrls() {
-        const filterKeyValues = new Map([]);
-        if (await this.checkRulesForSitemap(filterKeyValues)) {
-            return [this.getPathWithSortingOption('')];
+        try {
+            const filterKeyValues = new Map([]);
+            if (await this.checkRulesForSitemap(filterKeyValues)) {
+                return [this.getPathWithSortingOption('')];
+            }
+            return [];
+        }
+        catch (error) {
+            console.error('Error generating URLs for RankedUnfiltered:', error);
+            return [];
         }
-        return [];
     }
     get filterCombination() {
         return FilterCombinations.RANKED_UNFILTERED;

package/dist/src/organisations/rules/MinimumAmountOfRankedResultsRule.d.ts

@@ -7,7 +7,6 @@ export declare class MinimumAmountOfRankedResultsRule implements IRule {
     constructor(searchApiClient?: ISearchApiClient);
     forSearch(dependencies: IOrganisationSearchDependencies): Promise<boolean>;
     forSitemapGenerator(filterKeyValues: FilterKeyValuesMap): Promise<boolean>;
-    private mapResults;
     getName(): string;
     getDescription(): string;
 }

package/dist/src/organisations/rules/MinimumAmountOfRankedResultsRule.js

@@ -1,7 +1,4 @@
 import { DependencyMissingError } from '../../errors/DependencyMissingError';
-import { FILTER_KEY_TO_FILTER_TYPE_MAP } from '../../common/FilterKeyToFilterTypeMap';
-import { FilterType } from '@studyportals/omnisearch-interfaces';
-import { OrganisationSortType } from '@studyportals/search-api-interface';
 export class MinimumAmountOfRankedResultsRule {
     minimumRankedResultsCount = 4;
     searchApiClient;
@@ -17,21 +14,23 @@ export class MinimumAmountOfRankedResultsRule {
         if (!this.searchApiClient) {
             throw new DependencyMissingError('SearchApiClient');
         }
-        const mappedResults = this.mapResults(filterKeyValues);
-        const rankedResultsCount = await this.searchApiClient.getCount(mappedResults);
-        return rankedResultsCount >= this.minimumRankedResultsCount;
-    }
-    mapResults(filterKeyValues) {
-        const filterTypeMap = new Map([
-            [FilterType.SORTING, [OrganisationSortType.RANKINGS]]
-        ]);
-        for (const [filterKey, values] of filterKeyValues.entries()) {
-            const filterType = FILTER_KEY_TO_FILTER_TYPE_MAP.get(filterKey);
-            if (filterType) {
-                filterTypeMap.set(filterType, values);
-            }
+        if (!this.searchApiClient.getCountWithRankings) {
+            const filterKeys = [...filterKeyValues.keys()];
+            throw new DependencyMissingError(`CountwithRankings ${filterKeys.join(',')}`);
+        }
+        // eslint-disable-next-line no-console
+        console.debug('MinimumAmountOfRankedResultsRule: Checking ranked results count for filterKeyValues:', filterKeyValues);
+        try {
+            const rankedResultsCount = await this.searchApiClient.getCountWithRankings(filterKeyValues);
+            // eslint-disable-next-line no-console
+            console.debug('MinimumAmountOfRankedResultsRule: Ranked results count:', rankedResultsCount);
+            return rankedResultsCount >= this.minimumRankedResultsCount;
+        }
+        catch (error) {
+            // eslint-disable-next-line no-console
+            console.error('MinimumAmountOfRankedResultsRule: API call failed:', error);
+            throw error;
         }
-        return filterTypeMap;
     }
     getName() {
         return 'AtLeastFourRankedResultsRule';

package/dist/src/organisations/rules/MinimumAmountOfResultsRule.d.ts

@@ -9,7 +9,6 @@ export declare class MinimumAmountOfResultsRule implements IRule {
     constructor(searchApiClient?: ISearchApiClient);
     forSearch(dependencies: ISearchDependencies): Promise<boolean>;
     forSitemapGeneratorWithPageNumber(filterKeyValues: FilterKeyValuesMap, pageNumber: number): Promise<boolean>;
-    private mapResults;
     forSitemapGenerator(filterKeyValues: FilterKeyValuesMap): Promise<boolean>;
     getName(): string;
     getDescription(): string;

package/dist/src/organisations/rules/MinimumAmountOfResultsRule.js

@@ -1,7 +1,4 @@
 import { DependencyMissingError } from '../../errors/DependencyMissingError';
-import { FilterType } from '@studyportals/omnisearch-interfaces';
-import { OrganisationSortType } from '@studyportals/search-api-interface';
-import { FILTER_KEY_TO_FILTER_TYPE_MAP } from '../../common/FilterKeyToFilterTypeMap';
 export class MinimumAmountOfResultsRule {
     minimumResultsCount = 7;
     maximumPageSize = 20;
@@ -18,22 +15,9 @@ export class MinimumAmountOfResultsRule {
         if (!this.searchApiClient) {
             throw new DependencyMissingError('SearchApiClient');
         }
-        const mappedResults = this.mapResults(filterKeyValues);
-        const count = await this.searchApiClient.getCount(mappedResults);
+        const count = await this.searchApiClient.getCount(filterKeyValues);
         return count >= (pageNumber - 1) * this.maximumPageSize + this.minimumResultsCount;
     }
-    mapResults(filterKeyValues) {
-        const filterTypeMap = new Map([
-            [FilterType.SORTING, [OrganisationSortType.RANKINGS]]
-        ]);
-        for (const [filterKey, values] of filterKeyValues.entries()) {
-            const filterType = FILTER_KEY_TO_FILTER_TYPE_MAP.get(filterKey);
-            if (filterType) {
-                filterTypeMap.set(filterType, values);
-            }
-        }
-        return filterTypeMap;
-    }
     async forSitemapGenerator(filterKeyValues) {
         if (!this.searchApiClient) {
             throw new DependencyMissingError('SearchApiClient');

package/dist/src/programmes/rules/MinimumAmountOfResultsRule.d.ts

@@ -9,7 +9,6 @@ export declare class MinimumAmountOfResultsRule implements IProgrammeRule {
     constructor(searchApiClient?: ISearchApiClient);
     forSearch(dependencies: ISearchDependencies): Promise<boolean>;
     forSitemapGeneratorWithPageNumber(filterKeyValues: FilterKeyValuesMap, pageNumber: number): Promise<boolean>;
-    private mapResults;
     forSitemapGenerator(): Promise<boolean>;
     getName(): string;
     getDescription(): string;

package/dist/src/programmes/rules/MinimumAmountOfResultsRule.js

@@ -1,7 +1,4 @@
 import { DependencyMissingError } from '../../errors/DependencyMissingError';
-import { FilterType } from '@studyportals/omnisearch-interfaces';
-import { OrganisationSortType } from '@studyportals/search-api-interface';
-import { FILTER_KEY_TO_FILTER_TYPE_MAP } from '../../common/FilterKeyToFilterTypeMap';
 export class MinimumAmountOfResultsRule {
     minimumResultsCount = 7;
     maximumPageSize = 20;
@@ -18,22 +15,9 @@ export class MinimumAmountOfResultsRule {
         if (!this.searchApiClient) {
             throw new DependencyMissingError('SearchApiClient');
         }
-        const mappedResults = this.mapResults(filterKeyValues);
-        const count = await this.searchApiClient.getCount(mappedResults);
+        const count = await this.searchApiClient.getCount(filterKeyValues);
         return count >= (pageNumber - 1) * this.maximumPageSize + this.minimumResultsCount;
     }
-    mapResults(filterKeyValues) {
-        const filterTypeMap = new Map([
-            [FilterType.SORTING, [OrganisationSortType.RANKINGS]]
-        ]);
-        for (const [filterKey, values] of filterKeyValues.entries()) {
-            const filterType = FILTER_KEY_TO_FILTER_TYPE_MAP.get(filterKey);
-            if (filterType) {
-                filterTypeMap.set(filterType, values);
-            }
-        }
-        return filterTypeMap;
-    }
     forSitemapGenerator() {
         throw new Error('Method not implemented.');
     }

package/dist/src/sitemap-generator/BaseSitemapUrlGeneratorManager.js

@@ -17,6 +17,7 @@ export class BaseSitemapUrlGeneratorManager {
         for (const presenter of this.presenters.values()) {
             const count = presenter.getFragments().length;
             this.filterKeyValueCounts.set(presenter.filterKey, count);
+            console.debug(`Set filter key value count for ${presenter.filterKey}: ${count}`); // eslint-disable-line no-console
         }
     }
     getPolicies() {

package/dist/src/sitemap-generator/ISearchApiClient.d.ts

@@ -1,5 +1,4 @@
 import { FilterKeyValuesMap } from '../common/FilterKeyValuesMap';
-import { FilterTypeMap } from '../common/FilterTypeMap';
 export interface ISearchApiClient {
     getOrganisationIds(): Promise<number[]>;
     getCityIds?(): Promise<number[]>;
@@ -11,5 +10,6 @@ export interface ISearchApiClient {
         countryIsoCode: string;
     }[]>;
     getProgrammeCount?(filterKeyValues: FilterKeyValuesMap): Promise<number>;
-    getCount(filterKeyValues: FilterKeyValuesMap | FilterTypeMap): Promise<number>;
+    getCount(filterKeyValues: FilterKeyValuesMap): Promise<number>;
+    getCountWithRankings?(filterKeyValues: FilterKeyValuesMap): Promise<number>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@studyportals/fawkes",
-	"version": "8.7.2-2",
+	"version": "8.7.2-21",
 	"description": "A package to centralize SEO related logic for SBLP and Sitemap Generator.",
 	"files": [
 		"./dist"
@@ -91,9 +91,8 @@
 	},
 	"dependencies": {
 		"@studyportals/domain-client": "^8.1.0",
-		"@studyportals/omnisearch-interfaces": "^0.2.1",
-		"@studyportals/ranking-api-interface": "^1.3.12",
-		"@studyportals/search-api-interface": "^5.9.2",
+		"@studyportals/ranking-api-interface": "^2.4.0",
+		"@studyportals/search-api-interface": "5.9.3-0",
 		"@studyportals/search-filters": "^6.3.1",
 		"@studyportals/static-domain-data": "^6.1.0"
 	},