@studyportals/fawkes 9.0.0 → 9.0.1-0

package/dist/src/organisations/policies/our-picks/AreaAttendance.d.ts

@@ -9,7 +9,7 @@ export declare class AreaAttendance extends OrganisationsSeoIndexabilityPolicy {
     readonly name: string;
     readonly description: string;
     protected readonly sortingOption = SortingOptions.OUR_PICKS;
-    protected readonly baseRules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | OnlineAttendanceRule | SearchVolumeAreasAttendanceRule)[];
+    protected readonly baseRules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | SearchVolumeAreasAttendanceRule | OnlineAttendanceRule)[];
     protected generateUrls(): Promise<string[]>;
     get filterCombination(): FilterCombinations;
 }

package/dist/src/scholarships/SearchIndexabilityManager.d.ts

@@ -3,9 +3,10 @@ import { ISeoInfoBase } from '../common/ISeoInfoBase';
 import { ISeoFilterState } from '../common/ISeoFilterState';
 import { ISearchApplicationState } from '../common/ISearchApplicationState';
 import { ISearchIndexabilityManager } from '../common/ISearchIndexabilityManager';
+import { PortalType } from '@studyportals/domain-client';
 export declare class SearchIndexabilityManager implements ISearchIndexabilityManager {
     private policies;
-    constructor(seoInfoBase: ISeoInfoBase, filterState: ISeoFilterState, applicationState: ISearchApplicationState);
+    constructor(seoInfoBase: ISeoInfoBase, filterState: ISeoFilterState, applicationState: ISearchApplicationState, portalType?: PortalType);
     shouldIndex(): Promise<boolean>;
     getPolicies(): ISeoIndexabilityPolicy[];
 }

package/dist/src/scholarships/SearchIndexabilityManager.js

@@ -7,12 +7,13 @@ import { Unfiltered } from './policies/Unfiltered';
 import { DependencyTypes } from '../enums/DependencyTypes';
 export class SearchIndexabilityManager {
     policies;
-    constructor(seoInfoBase, filterState, applicationState) {
+    constructor(seoInfoBase, filterState, applicationState, portalType) {
         const dependencies = {
             dependencyType: DependencyTypes.SEARCH,
             seoInfoBase,
             filterState,
-            applicationState
+            applicationState,
+            portalType
         };
         this.policies = [
             new Area(dependencies),

package/dist/src/scholarships/policies/Area.d.ts

@@ -1,13 +1,12 @@
+import { IRule } from '../../common/IRule';
+import { IScholarshipSeoDependencies } from '../types/IScholarshipSeoDependencies';
 import { FilterCombinations } from '../../enums/FilterCombinations';
-import { ExceptAustraliaAreasRule } from '../rules/ExceptAustaliaAreasRule';
-import { SearchVolumeAreasRule } from '../rules/SearchVolumeAreasRule';
 import { ScholarshipSeoIndexabilityPolicy } from './ScholarshipSeoIndexabilityPolicy';
-import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
-import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
 export declare class Area extends ScholarshipSeoIndexabilityPolicy {
     readonly name: string;
     readonly description: string;
-    protected readonly baseRules: (ExceptAustraliaAreasRule | SearchVolumeAreasRule | SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule)[];
+    protected readonly baseRules: IRule[];
+    constructor(dependencies: IScholarshipSeoDependencies);
     get filterCombination(): FilterCombinations;
     protected generateUrls(): Promise<string[]>;
 }

package/dist/src/scholarships/policies/Area.js

@@ -1,3 +1,5 @@
+import { NotOnPortalsRule } from '../rules/NotOnPortalsRule';
+import { PortalType } from '@studyportals/domain-client';
 import { FilterKey } from '@studyportals/search-filters/server-side';
 import { FilterCombinations } from '../../enums/FilterCombinations';
 import { ExceptAustraliaAreasRule } from '../rules/ExceptAustaliaAreasRule';
@@ -9,13 +11,18 @@ import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedR
 export class Area extends ScholarshipSeoIndexabilityPolicy {
     name = 'Area Policy';
     description = 'Controls indexing of pages filtered by geographic areas, ensuring only SEO-valuable regional content with sufficient search volume is indexed while respecting country associations.';
-    baseRules = [
-        new SingleValueSelectedForFilterRule(FilterKey.AREA),
-        new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
-        new OnlyFiltersSelectedRule([FilterKey.AREA, FilterKey.COUNTRY]),
-        new ExceptAustraliaAreasRule(),
-        new SearchVolumeAreasRule()
-    ];
+    baseRules;
+    constructor(dependencies) {
+        super(dependencies);
+        this.baseRules = [
+            new NotOnPortalsRule([PortalType.BACHELOR, PortalType.PHD], this.portalType),
+            new SingleValueSelectedForFilterRule(FilterKey.AREA),
+            new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
+            new OnlyFiltersSelectedRule([FilterKey.AREA, FilterKey.COUNTRY]),
+            new ExceptAustraliaAreasRule(),
+            new SearchVolumeAreasRule()
+        ];
+    }
     get filterCombination() {
         return FilterCombinations.AREA;
     }

package/dist/src/scholarships/policies/DisciplineCountry.d.ts

@@ -1,12 +1,12 @@
+import { IRule } from '../../common/IRule';
+import { IScholarshipSeoDependencies } from '../types/IScholarshipSeoDependencies';
 import { FilterCombinations } from '../../enums/FilterCombinations';
-import { SearchVolumeCountriesDisciplinesRule } from '../rules/SearchVolumeCountriesDisciplinesRule';
 import { ScholarshipSeoIndexabilityPolicy } from './ScholarshipSeoIndexabilityPolicy';
-import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
-import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
 export declare class DisciplineCountry extends ScholarshipSeoIndexabilityPolicy {
     readonly name: string;
     readonly description: string;
-    protected readonly baseRules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | SearchVolumeCountriesDisciplinesRule)[];
+    protected readonly baseRules: IRule[];
+    constructor(dependencies: IScholarshipSeoDependencies);
     get filterCombination(): FilterCombinations;
     protected generateUrls(): Promise<string[]>;
 }

package/dist/src/scholarships/policies/DisciplineCountry.js

@@ -1,3 +1,5 @@
+import { NotOnPortalsRule } from '../rules/NotOnPortalsRule';
+import { PortalType } from '@studyportals/domain-client';
 import { FilterKey } from '@studyportals/search-filters/server-side';
 import { FilterCombinations } from '../../enums/FilterCombinations';
 import { SearchVolumeCountriesDisciplinesRule } from '../rules/SearchVolumeCountriesDisciplinesRule';
@@ -6,15 +8,22 @@ import { DisciplinePresenter } from '../../presenters/DisciplinePresenter';
 import { ScholarshipSeoIndexabilityPolicy } from './ScholarshipSeoIndexabilityPolicy';
 import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
 import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { OnlyCountriesDisciplineCountryRule } from '../rules/OnlyCountriesDisciplineCountryRule';
 export class DisciplineCountry extends ScholarshipSeoIndexabilityPolicy {
     name = 'Discipline Policy';
     description = 'Determines which discipline-filtered pages qualify for indexing based on search volume thresholds and content availability within specific academic fields.';
-    baseRules = [
-        new SingleValueSelectedForFilterRule(FilterKey.DISCIPLINES),
-        new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
-        new OnlyFiltersSelectedRule([FilterKey.DISCIPLINES, FilterKey.COUNTRY]),
-        new SearchVolumeCountriesDisciplinesRule()
-    ];
+    baseRules;
+    constructor(dependencies) {
+        super(dependencies);
+        this.baseRules = [
+            new NotOnPortalsRule([PortalType.BACHELOR, PortalType.PHD], this.portalType),
+            new SingleValueSelectedForFilterRule(FilterKey.DISCIPLINES),
+            new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
+            new OnlyFiltersSelectedRule([FilterKey.DISCIPLINES, FilterKey.COUNTRY]),
+            new SearchVolumeCountriesDisciplinesRule(),
+            new OnlyCountriesDisciplineCountryRule()
+        ];
+    }
     get filterCombination() {
         return FilterCombinations.DISCIPLINE_COUNTRY;
     }

package/dist/src/scholarships/policies/ScholarshipSeoIndexabilityPolicy.d.ts

@@ -1,7 +1,9 @@
 import { BaseSeoIndexabilityPolicy } from '../../common/policies/BaseSeoIndexabilityPolicy';
 import { IScholarshipSeoDependencies } from '../types/IScholarshipSeoDependencies';
 import { IRule } from '../../common/IRule';
+import { PortalType } from '@studyportals/domain-client';
 export declare abstract class ScholarshipSeoIndexabilityPolicy extends BaseSeoIndexabilityPolicy<IScholarshipSeoDependencies> {
     protected abstract readonly baseRules: IRule[];
+    protected get portalType(): PortalType;
     protected get rules(): IRule[];
 }

package/dist/src/scholarships/policies/ScholarshipSeoIndexabilityPolicy.js

@@ -1,6 +1,10 @@
 import { BaseSeoIndexabilityPolicy } from '../../common/policies/BaseSeoIndexabilityPolicy';
 import { IndexablePageNumberRule } from '../../common/rules/IndexablePageNumberRule';
+import { PortalType } from '@studyportals/domain-client';
 export class ScholarshipSeoIndexabilityPolicy extends BaseSeoIndexabilityPolicy {
+    get portalType() {
+        return this.dependencies.portalType ?? PortalType.MASTER;
+    }
     get rules() {
         return [...this.baseRules, new IndexablePageNumberRule()];
     }

package/dist/src/scholarships/policies/UniversityCountry.d.ts

@@ -1,11 +1,13 @@
+import { IRule } from '../../common/IRule';
+import { IScholarshipSeoDependencies } from '../types/IScholarshipSeoDependencies';
 import { FilterCombinations } from '../../enums/FilterCombinations';
 import { ScholarshipSeoIndexabilityPolicy } from './ScholarshipSeoIndexabilityPolicy';
-import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
-import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
 export declare class UniversityCountry extends ScholarshipSeoIndexabilityPolicy {
     readonly name: string;
     readonly description: string;
-    protected readonly baseRules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule)[];
+    protected readonly baseRules: IRule[];
+    private readonly portalRule;
+    constructor(dependencies: IScholarshipSeoDependencies);
     get filterCombination(): FilterCombinations;
     protected generateUrls(): Promise<string[]>;
 }

package/dist/src/scholarships/policies/UniversityCountry.js

@@ -1,3 +1,5 @@
+import { NotOnPortalsRule } from '../rules/NotOnPortalsRule';
+import { PortalType } from '@studyportals/domain-client';
 import { FilterKey } from '@studyportals/search-filters/server-side';
 import { FilterCombinations } from '../../enums/FilterCombinations';
 import { CountryPresenter } from '../../presenters/CountryPresenter';
@@ -7,15 +9,25 @@ import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedR
 export class UniversityCountry extends ScholarshipSeoIndexabilityPolicy {
     name = 'University Country Policy';
     description = 'Regulates indexing for pages filtered by both university and country, prioritizing institution-specific content within national boundaries that meets SEO criteria.';
-    baseRules = [
-        new SingleValueSelectedForFilterRule(FilterKey.ORGANISATIONS),
-        new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
-        new OnlyFiltersSelectedRule([FilterKey.ORGANISATIONS, FilterKey.COUNTRY])
-    ];
+    baseRules;
+    portalRule;
+    constructor(dependencies) {
+        super(dependencies);
+        this.portalRule = new NotOnPortalsRule([PortalType.BACHELOR], this.portalType);
+        this.baseRules = [
+            this.portalRule,
+            new SingleValueSelectedForFilterRule(FilterKey.ORGANISATIONS),
+            new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
+            new OnlyFiltersSelectedRule([FilterKey.ORGANISATIONS, FilterKey.COUNTRY])
+        ];
+    }
     get filterCombination() {
         return FilterCombinations.UNIVERSITY_COUNTRY;
     }
     async generateUrls() {
+        if (!(await this.portalRule.forSitemapGenerator())) {
+            return [];
+        }
         const { searchApiClient, organisationsClient } = this.dependencies;
         try {
             const organisationIds = await searchApiClient.getOrganisationIds();

package/dist/src/scholarships/rules/NotOnPortalsRule.d.ts

@@ -0,0 +1,12 @@
+import { IRule } from '../../common/IRule';
+import { PortalType } from '@studyportals/domain-client';
+export declare class NotOnPortalsRule implements IRule {
+    private readonly blockedPortals;
+    private readonly portalType;
+    constructor(blockedPortals: PortalType[], portalType?: PortalType);
+    getName(): string;
+    forSearch(): Promise<boolean>;
+    forSitemapGenerator(): Promise<boolean>;
+    private isAllowedOnPortal;
+    getDescription(): string;
+}

package/dist/src/scholarships/rules/NotOnPortalsRule.js

@@ -0,0 +1,24 @@
+import { PortalType } from '@studyportals/domain-client';
+export class NotOnPortalsRule {
+    blockedPortals;
+    portalType;
+    constructor(blockedPortals, portalType = PortalType.MASTER) {
+        this.blockedPortals = blockedPortals;
+        this.portalType = portalType;
+    }
+    getName() {
+        return 'NotOnPortalsRule';
+    }
+    forSearch() {
+        return Promise.resolve(this.isAllowedOnPortal());
+    }
+    forSitemapGenerator() {
+        return Promise.resolve(this.isAllowedOnPortal());
+    }
+    isAllowedOnPortal() {
+        return !this.blockedPortals.includes(this.portalType);
+    }
+    getDescription() {
+        return `Is indexable if the portal type is not one of: ${this.blockedPortals.join(', ')}.`;
+    }
+}

package/dist/src/scholarships/rules/OnlyCountriesDisciplineCountryRule.d.ts

@@ -0,0 +1,13 @@
+import { IRule } from "../../common/IRule";
+import { ISearchDependencies } from "../../common/ISearchDependencies";
+import { FilterKeyValuesMap } from "../../../sitemap-generator-seo";
+export declare class OnlyCountriesDisciplineCountryRule implements IRule {
+    private readonly countryFilterKey;
+    private readonly allowedCountryIsos;
+    private allowedCountryIds?;
+    getName(): string;
+    forSearch(dependencies: ISearchDependencies): Promise<boolean>;
+    forSitemapGenerator(filterKeyValues: FilterKeyValuesMap): Promise<boolean>;
+    private getAllowedCountryIds;
+    getDescription(): string;
+}

package/dist/src/scholarships/rules/OnlyCountriesDisciplineCountryRule.js

@@ -0,0 +1,40 @@
+import { FilterKey } from "@studyportals/search-filters/server-side";
+import { CountryPresenter } from "../../presenters/CountryPresenter";
+export class OnlyCountriesDisciplineCountryRule {
+    countryFilterKey = FilterKey.COUNTRY;
+    allowedCountryIsos = ['AU', 'CA', 'CN', 'FR', 'DE', 'IN', 'IE', 'IT', 'JP', 'MY', 'NL', 'NZ', 'SG', 'KR', 'CH', 'GB', 'US'];
+    allowedCountryIds;
+    getName() {
+        return 'OnlyCountriesDisciplineCountryRule';
+    }
+    forSearch(dependencies) {
+        const selectedCountry = dependencies.seoInfoBase.getFilterOptionValueBy(this.countryFilterKey, dependencies.filterState);
+        if (!selectedCountry) {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve(this.getAllowedCountryIds().has(selectedCountry));
+    }
+    forSitemapGenerator(filterKeyValues) {
+        const selectedCountries = filterKeyValues.get(FilterKey.COUNTRY);
+        if (!selectedCountries || selectedCountries.length !== 1) {
+            return Promise.resolve(false);
+        }
+        const selectedCountry = selectedCountries[0];
+        if (!selectedCountry) {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve(this.getAllowedCountryIds().has(selectedCountry));
+    }
+    getAllowedCountryIds() {
+        if (!this.allowedCountryIds) {
+            this.allowedCountryIds = new Set(CountryPresenter.getInstance()
+                .getFragments()
+                .filter((country) => this.allowedCountryIsos.includes(country.iso))
+                .map((country) => country.id));
+        }
+        return this.allowedCountryIds;
+    }
+    getDescription() {
+        return 'Country is one of the allowed countries for discipline and country pages';
+    }
+}

package/dist/src/scholarships/types/IScholarshipSearchDependencies.d.ts

@@ -0,0 +1,5 @@
+import { ISearchDependencies } from '../../common/ISearchDependencies';
+import { PortalType } from '@studyportals/domain-client';
+export interface IScholarshipSearchDependencies extends ISearchDependencies {
+    portalType?: PortalType;
+}

package/dist/src/scholarships/types/IScholarshipSearchDependencies.js

@@ -0,0 +1 @@
+export {};

package/dist/src/scholarships/types/IScholarshipSeoDependencies.d.ts

@@ -1,3 +1,3 @@
-import { ISearchDependencies } from '../../common/ISearchDependencies';
+import { IScholarshipSearchDependencies } from './IScholarshipSearchDependencies';
 import { IScholarshipSitemapDependencies } from './IScholarshipSitemapDependencies';
-export type IScholarshipSeoDependencies = ISearchDependencies | IScholarshipSitemapDependencies;
+export type IScholarshipSeoDependencies = IScholarshipSearchDependencies | IScholarshipSitemapDependencies;

package/dist/src/scholarships/types/IScholarshipSitemapDependencies.d.ts

@@ -1,5 +1,7 @@
 import { ISitemapDependencies } from '../../common/ISitemapDependencies';
 import { IOrganisationsClient } from '../../sitemap-generator/IOrganisationsClient';
+import { PortalType } from '@studyportals/domain-client';
 export interface IScholarshipSitemapDependencies extends ISitemapDependencies {
     organisationsClient: IOrganisationsClient;
+    portalType?: PortalType;
 }

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

@@ -1,9 +1,10 @@
 import { ISitemapUrlGenerator } from '../common/ISitemapUrlGenerator';
 import { IOrganisationsClient } from '../sitemap-generator/IOrganisationsClient';
 import { ISearchApiClient } from '../sitemap-generator/ISearchApiClient';
+import { PortalType } from '@studyportals/domain-client';
 import { BaseSitemapUrlGeneratorManager } from './BaseSitemapUrlGeneratorManager';
 export declare class ScholarshipsSitemapUrlGeneratorManager extends BaseSitemapUrlGeneratorManager {
     readonly policies: ISitemapUrlGenerator[];
     readonly presenters: Map<any, any>;
-    constructor(searchApiClient: ISearchApiClient, organisationsClient: IOrganisationsClient);
+    constructor(searchApiClient: ISearchApiClient, organisationsClient: IOrganisationsClient, portalType?: PortalType);
 }

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

@@ -9,12 +9,13 @@ import { BaseSitemapUrlGeneratorManager } from './BaseSitemapUrlGeneratorManager
 export class ScholarshipsSitemapUrlGeneratorManager extends BaseSitemapUrlGeneratorManager {
     policies;
     presenters = new Map();
-    constructor(searchApiClient, organisationsClient) {
+    constructor(searchApiClient, organisationsClient, portalType) {
         super();
         const dependencies = {
             dependencyType: DependencyTypes.SITEMAP_GENERATOR,
             searchApiClient,
-            organisationsClient
+            organisationsClient,
+            portalType
         };
         this.policies = [
             new Area(dependencies),

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@studyportals/fawkes",
-	"version": "9.0.0",
+	"version": "9.0.1-0",
 	"description": "A package to centralize SEO related logic for SBLP and Sitemap Generator.",
 	"files": [
 		"./dist"