@studyportals/fawkes 8.0.1-5 → 8.0.1

package/dist/src/organisations/policies/OrganisationsSeoIndexabilityPolicy.d.ts

@@ -13,7 +13,7 @@ export declare abstract class OrganisationsSeoIndexabilityPolicy extends BaseSeo
     protected addRule(rule: IRule): void;
     generateSitemapUrls(): Promise<string[]>;
     protected isIndexable(): Promise<boolean>;
-    protected addResultsCountRule(): void;
+    protected addMinimumAmountOfResultsRule(): void;
     protected getPathWithSortingOption(path: string): string;
     private matchesSortingOption;
 }

package/dist/src/organisations/policies/OrganisationsSeoIndexabilityPolicy.js

@@ -1,13 +1,13 @@
 import { PortalType } from '@studyportals/domain-client';
 import { BaseSeoIndexabilityPolicy } from '../../common/policies/BaseSeoIndexabilityPolicy';
 import { IndexablePageNumberRule } from '../../common/rules/IndexablePageNumberRule';
-import { AtLeastSevenResultsRule } from '../../organisations/rules/AtLeastSevenResultsRule';
+import { MinimumAmountOfResultsRule } from '../../organisations/rules/MinimumAmountOfResultsRule';
 export class OrganisationsSeoIndexabilityPolicy extends BaseSeoIndexabilityPolicy {
     indexablePortalTypes = [PortalType.MASTER];
     additionalRules = [];
     constructor(dependencies) {
         super(dependencies);
-        this.addResultsCountRule();
+        this.addMinimumAmountOfResultsRule();
     }
     get rules() {
         return [...this.baseRules, ...this.additionalRules, new IndexablePageNumberRule()];
@@ -28,14 +28,14 @@ export class OrganisationsSeoIndexabilityPolicy extends BaseSeoIndexabilityPolic
         }
         return this.indexablePortalTypes.includes(this.dependencies.portalType) && this.matchesSortingOption();
     }
-    addResultsCountRule() {
+    addMinimumAmountOfResultsRule() {
         let resultCountRUle;
         if (super.isSitemapUrlGeneratorDependencies()) {
             const dependencies = this.dependencies;
-            resultCountRUle = new AtLeastSevenResultsRule(dependencies.searchApiClient);
+            resultCountRUle = new MinimumAmountOfResultsRule(dependencies.searchApiClient);
         }
         else {
-            resultCountRUle = new AtLeastSevenResultsRule();
+            resultCountRUle = new MinimumAmountOfResultsRule();
         }
         this.addRule(resultCountRUle);
     }

package/dist/src/organisations/policies/RankedOrganisationsSeoIndexabilityPolicy.d.ts

@@ -4,6 +4,6 @@ import { OrganisationsSeoIndexabilityPolicy } from './OrganisationsSeoIndexabili
 export declare abstract class RankedOrganisationsSeoIndexabilityPolicy extends OrganisationsSeoIndexabilityPolicy {
     protected readonly indexablePortalTypes: PortalType[];
     protected readonly sortingOption: SortingOptions;
-    protected addResultsCountRule(): void;
+    protected addMinimumAmountOfResultsRule(): void;
     protected getPathWithSortingOption(path: string): string;
 }

package/dist/src/organisations/policies/RankedOrganisationsSeoIndexabilityPolicy.js

@@ -1,18 +1,18 @@
 import { PortalType } from '@studyportals/domain-client';
 import { SortingOptions } from '../../enums/SortingOptions';
 import { OrganisationsSeoIndexabilityPolicy } from './OrganisationsSeoIndexabilityPolicy';
-import { AtLeastTwoRankedResultsRule } from '../rules/AtLeastTwoRankedResultsRule';
+import { MinimumAmountOfRankedResultsRule } from '../rules/MinimumAmountOfRankedResultsRule';
 export class RankedOrganisationsSeoIndexabilityPolicy extends OrganisationsSeoIndexabilityPolicy {
     indexablePortalTypes = [PortalType.MASTER];
     sortingOption = SortingOptions.UNIVERSITY_META_RANKING;
-    addResultsCountRule() {
+    addMinimumAmountOfResultsRule() {
         let rankedResultsCountRule;
         if (super.isSitemapUrlGeneratorDependencies()) {
             const dependencies = this.dependencies;
-            rankedResultsCountRule = new AtLeastTwoRankedResultsRule(dependencies.rankingApiClient);
+            rankedResultsCountRule = new MinimumAmountOfRankedResultsRule(dependencies.rankingApiClient);
         }
         else {
-            rankedResultsCountRule = new AtLeastTwoRankedResultsRule();
+            rankedResultsCountRule = new MinimumAmountOfRankedResultsRule();
         }
         this.addRule(rankedResultsCountRule);
     }

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

@@ -0,0 +1,13 @@
+import { IRule } from '../../common/IRule';
+import { IOrganisationSearchDependencies } from '../types/IOrganisationSearchDependencies';
+import { FilterKeyValuesMap } from '../../common/FilterKeyValuesMap';
+import { IRankingApiClient } from '../../sitemap-generator/IRankingApiClient';
+export declare class AtLeastSevenRankedResultsRule implements IRule {
+    private readonly minimumRankedResultsCount;
+    private readonly rankingApiClient?;
+    constructor(rankingApiClient?: IRankingApiClient);
+    forSearch(dependencies: IOrganisationSearchDependencies): Promise<boolean>;
+    forSitemapGenerator(filterKeyValues: FilterKeyValuesMap): Promise<boolean>;
+    getName(): string;
+    getDescription(): string;
+}

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

@@ -0,0 +1,26 @@
+import { DependencyMissingError } from '../../errors/DependencyMissingError';
+export class AtLeastSevenRankedResultsRule {
+    minimumRankedResultsCount = 7;
+    rankingApiClient;
+    constructor(rankingApiClient) {
+        this.rankingApiClient = rankingApiClient;
+    }
+    forSearch(dependencies) {
+        const { applicationState } = dependencies;
+        const rankedResultsCount = applicationState.getRankedResultsCount();
+        return Promise.resolve(rankedResultsCount >= this.minimumRankedResultsCount);
+    }
+    async forSitemapGenerator(filterKeyValues) {
+        if (!this.rankingApiClient) {
+            throw new DependencyMissingError('RankingApiClient');
+        }
+        const rankedResultsCount = await this.rankingApiClient.getRankedOrganisationCount(filterKeyValues);
+        return rankedResultsCount >= this.minimumRankedResultsCount;
+    }
+    getName() {
+        return 'AtLeastTwoRankedResultsRule';
+    }
+    getDescription() {
+        return `At least ${this.minimumRankedResultsCount} ranked results are available`;
+    }
+}

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

@@ -29,6 +29,6 @@ export class AtLeastSevenResultsRule {
         return 'AtLeastSevenResultsRule';
     }
     getDescription() {
-        return 'Is indexable if there are at least 2 results.';
+        return 'Is indexable if there are at least 6 results.';
     }
 }

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

@@ -0,0 +1,13 @@
+import { IRule } from '../../common/IRule';
+import { IOrganisationSearchDependencies } from '../types/IOrganisationSearchDependencies';
+import { FilterKeyValuesMap } from '../../common/FilterKeyValuesMap';
+import { IRankingApiClient } from '../../sitemap-generator/IRankingApiClient';
+export declare class MinimumAmountOfRankedResultsRule implements IRule {
+    private readonly minimumRankedResultsCount;
+    private readonly rankingApiClient?;
+    constructor(rankingApiClient?: IRankingApiClient);
+    forSearch(dependencies: IOrganisationSearchDependencies): Promise<boolean>;
+    forSitemapGenerator(filterKeyValues: FilterKeyValuesMap): Promise<boolean>;
+    getName(): string;
+    getDescription(): string;
+}

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

@@ -0,0 +1,26 @@
+import { DependencyMissingError } from '../../errors/DependencyMissingError';
+export class MinimumAmountOfRankedResultsRule {
+    minimumRankedResultsCount = 7;
+    rankingApiClient;
+    constructor(rankingApiClient) {
+        this.rankingApiClient = rankingApiClient;
+    }
+    forSearch(dependencies) {
+        const { applicationState } = dependencies;
+        const rankedResultsCount = applicationState.getRankedResultsCount();
+        return Promise.resolve(rankedResultsCount >= this.minimumRankedResultsCount);
+    }
+    async forSitemapGenerator(filterKeyValues) {
+        if (!this.rankingApiClient) {
+            throw new DependencyMissingError('RankingApiClient');
+        }
+        const rankedResultsCount = await this.rankingApiClient.getRankedOrganisationCount(filterKeyValues);
+        return rankedResultsCount >= this.minimumRankedResultsCount;
+    }
+    getName() {
+        return 'AtLeastTwoRankedResultsRule';
+    }
+    getDescription() {
+        return `At least ${this.minimumRankedResultsCount} ranked results are available`;
+    }
+}

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

@@ -0,0 +1,15 @@
+import { ISearchDependencies } from '../../common/ISearchDependencies';
+import { FilterKeyValuesMap } from '../../common/FilterKeyValuesMap';
+import { ISearchApiClient } from '../../sitemap-generator/ISearchApiClient';
+import { IRule } from '../../common/IRule';
+export declare class MinimumAmountOfResultsRule implements IRule {
+    private readonly minimumResultsCount;
+    private readonly maximumPageSize;
+    private readonly searchApiClient?;
+    constructor(searchApiClient?: ISearchApiClient);
+    forSearch(dependencies: ISearchDependencies): Promise<boolean>;
+    forSitemapGeneratorWithPageNumber(filterKeyValues: FilterKeyValuesMap, pageNumber: number): Promise<boolean>;
+    forSitemapGenerator(filterKeyValues: FilterKeyValuesMap): Promise<boolean>;
+    getName(): string;
+    getDescription(): string;
+}

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

@@ -0,0 +1,34 @@
+import { DependencyMissingError } from '../../errors/DependencyMissingError';
+export class MinimumAmountOfResultsRule {
+    minimumResultsCount = 7;
+    maximumPageSize = 20;
+    searchApiClient;
+    constructor(searchApiClient) {
+        this.searchApiClient = searchApiClient;
+    }
+    forSearch(dependencies) {
+        const { applicationState } = dependencies;
+        const resultCount = applicationState.getNumberOfResults();
+        return Promise.resolve(resultCount >= this.minimumResultsCount);
+    }
+    async forSitemapGeneratorWithPageNumber(filterKeyValues, pageNumber) {
+        if (!this.searchApiClient) {
+            throw new DependencyMissingError('SearchApiClient');
+        }
+        const count = await this.searchApiClient.getCount(filterKeyValues);
+        return count >= (pageNumber - 1) * this.maximumPageSize + this.minimumResultsCount;
+    }
+    async forSitemapGenerator(filterKeyValues) {
+        if (!this.searchApiClient) {
+            throw new DependencyMissingError('SearchApiClient');
+        }
+        const resultsCount = await this.searchApiClient?.getCount(filterKeyValues);
+        return resultsCount >= this.minimumResultsCount;
+    }
+    getName() {
+        return 'AtLeastSevenResultsRule';
+    }
+    getDescription() {
+        return 'Is indexable if there are at least 6 results.';
+    }
+}

package/dist/src/programmes/ProgrammesBaseIndexabilityPolicy.js

@@ -1,4 +1,4 @@
-import { AtLeastSevenResultsRule } from './rules/AtLeastSevenResultsRule';
+import { MinimumAmountOfResultsRule } from './rules/MinimumAmountOfResultsRule';
 import { IndexablePageNumberRule } from './rules/IndexablePageNumberRule';
 import { NotDistanceLearningPortalRule } from './rules/NotDistanceLearningPortalRule';
 import { BaseSeoIndexabilityPolicy } from '../common/policies/BaseSeoIndexabilityPolicy';
@@ -10,11 +10,11 @@ export class ProgrammesBaseIndexabilityPolicy extends BaseSeoIndexabilityPolicy
         let notDistanceLearningPortalRule;
         if (super.isSitemapUrlGeneratorDependencies()) {
             const dependencies = this.dependencies;
-            atLeastSevenResultsRule = new AtLeastSevenResultsRule(dependencies.searchApiClient);
+            atLeastSevenResultsRule = new MinimumAmountOfResultsRule(dependencies.searchApiClient);
             notDistanceLearningPortalRule = new NotDistanceLearningPortalRule(dependencies.portalType);
         }
         else {
-            atLeastSevenResultsRule = new AtLeastSevenResultsRule();
+            atLeastSevenResultsRule = new MinimumAmountOfResultsRule();
             notDistanceLearningPortalRule = new NotDistanceLearningPortalRule();
         }
         this.rules.push(atLeastSevenResultsRule, notDistanceLearningPortalRule, indexablePageNumberRule);

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

@@ -0,0 +1,15 @@
+import { ISearchDependencies } from '../../common/ISearchDependencies';
+import { FilterKeyValuesMap } from '../../common/FilterKeyValuesMap';
+import { ISearchApiClient } from '../../sitemap-generator/ISearchApiClient';
+import { IProgrammeRule } from '../IProgrammeRule';
+export declare class MinimumAmountOfResultsRule implements IProgrammeRule {
+    private readonly minimumResultsCount;
+    private readonly maximumPageSize;
+    private readonly searchApiClient?;
+    constructor(searchApiClient?: ISearchApiClient);
+    forSearch(dependencies: ISearchDependencies): Promise<boolean>;
+    forSitemapGeneratorWithPageNumber(filterKeyValues: FilterKeyValuesMap, pageNumber: number): Promise<boolean>;
+    forSitemapGenerator(): Promise<boolean>;
+    getName(): string;
+    getDescription(): string;
+}

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

@@ -0,0 +1,30 @@
+import { DependencyMissingError } from '../../errors/DependencyMissingError';
+export class MinimumAmountOfResultsRule {
+    minimumResultsCount = 7;
+    maximumPageSize = 20;
+    searchApiClient;
+    constructor(searchApiClient) {
+        this.searchApiClient = searchApiClient;
+    }
+    forSearch(dependencies) {
+        const { applicationState } = dependencies;
+        const resultCount = applicationState.getNumberOfResults();
+        return Promise.resolve(resultCount >= this.minimumResultsCount);
+    }
+    async forSitemapGeneratorWithPageNumber(filterKeyValues, pageNumber) {
+        if (!this.searchApiClient) {
+            throw new DependencyMissingError('SearchApiClient');
+        }
+        const count = await this.searchApiClient.getCount(filterKeyValues);
+        return count >= (pageNumber - 1) * this.maximumPageSize + this.minimumResultsCount;
+    }
+    forSitemapGenerator() {
+        throw new Error('Method not implemented.');
+    }
+    getName() {
+        return 'AtLeastSevenResultsRule';
+    }
+    getDescription() {
+        return 'Is indexable if there are at least 7 results.';
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@studyportals/fawkes",
-	"version": "8.0.1-5",
+	"version": "8.0.1",
 	"description": "A package to centralize SEO related logic for SBLP and Sitemap Generator.",
 	"files": [
 		"./dist"
@@ -11,7 +11,7 @@
 		"compile": "npx tsc && tsc-alias && rm -r ./dist/tests",
 		"build": "npm run clean && npm run compile",
 		"clean": "rimraf \"!(node_modules)/**/dist\"",
-		"prepare-deployment": "npm run build",
+		"prepare-deployment": "npm run test && npm run build",
 		"publish-major": "npm run prepare-deployment && npm version major && npm publish",
 		"publish-beta": "npm run prepare-deployment && npm version prerelease && npm publish --tag beta --access=public",
 		"publish-patch": "npm run prepare-deployment && npm version patch && npm publish",
@@ -92,7 +92,7 @@
 	"dependencies": {
 		"@studyportals/domain-client": "^6.3.0",
 		"@studyportals/ranking-api-interface": "^1.3.12",
-		"@studyportals/search-filters": "^6.0.0",
+		"@studyportals/search-filters": "^6.1.0",
 		"@studyportals/static-domain-data": "^6.1.0"
 	},
 	"optionalDependencies": {