@studyportals/domain-client 3.17.1 → 3.18.0

package/{src → bin/src}/types/portal-type.js

@@ -1,12 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PortalType = void 0;
-var PortalType;
-(function (PortalType) {
-    PortalType["MASTER"] = "master";
-    PortalType["BACHELOR"] = "bachelor";
-    PortalType["PHD"] = "phd";
-    PortalType["SHORT"] = "short";
-    PortalType["DISTANCE_LEARNING"] = "distance_learning";
-})(PortalType = exports.PortalType || (exports.PortalType = {}));
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PortalType = void 0;
+var PortalType;
+(function (PortalType) {
+    PortalType["MASTER"] = "master";
+    PortalType["BACHELOR"] = "bachelor";
+    PortalType["PHD"] = "phd";
+    PortalType["SHORT"] = "short";
+    PortalType["DISTANCE_LEARNING"] = "distance_learning";
+})(PortalType = exports.PortalType || (exports.PortalType = {}));
 //# sourceMappingURL=portal-type.js.map

package/{src → bin/src}/types.d.ts

@@ -1,4 +1,4 @@
-export type Model = Record<string, Callable>;
-export type Callable = () => CallableReturnType | CallableReturnType[];
-export type CallableReturnType = AcceptedType | Model;
-export type AcceptedType = string | string[] | number | number[] | boolean | null | Date;
+export type Model = Record<string, Callable>;
+export type Callable = () => CallableReturnType | CallableReturnType[];
+export type CallableReturnType = AcceptedType | Model;
+export type AcceptedType = string | string[] | number | number[] | boolean | null | Date;

package/{src → bin/src}/types.js

@@ -1,3 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=types.js.map

package/index.ts

@@ -0,0 +1,147 @@
+import { BadRequestException } from "./src/exceptions/bad-request-exception"
+import { ClientException } from "./src/exceptions/client-exception"
+import { InternalServerException } from "./src/exceptions/internal-server-exception"
+import { NotFoundException } from "./src/exceptions/not-found-exception"
+import { PropertyNotAvailableException } from "./src/exceptions/property-not-available-exception"
+import { ICover } from "./src/models/programme-card/i-cover";
+import { ILink } from "./src/models/programme-card/i-link";
+import { IOptionalLink } from "./src/models/programme-card/i-optional-link";
+import { ILocation } from "./src/models/programme-card/i-location";
+import { IClickTrackingData } from "./src/models/programme-card/i-click-tracking-data";
+import { ITracking } from "./src/models/programme-card/i-tracking";
+import { IDuration } from "./src/models/programme-card/i-duration";
+import { IDeadline } from "./src/models/programme-card/i-deadline";
+import { IStartDate } from "./src/models/programme-card/i-start-date";
+import { ITiming } from "./src/models/programme-card/i-timing";
+import { ITrackedLink } from "./src/models/programme-card/i-tracked-link";
+import { IProgrammeCard } from "./src/models/programme-card/i-programme-card";
+import { ProgrammeCardClient } from "./src/models/programme-card/programme-card-client";
+import { ITuitionValues } from "./src/models/search-projection/i-tuition-values";
+import { IPremiumValues } from "./src/models/search-projection/i-premium-values";
+import { IOrganisationValues } from "./src/models/search-projection/i-organisation-values";
+import { IGeoTargetingConfiguration } from "./src/models/search-projection/i-geo-targeting-configuration";
+import { IGeoTargetingValues } from "./src/models/search-projection/i-geo-targeting-values";
+import { ISearchProjection } from "./src/models/search-projection/i-search-projection";
+import { SearchProjectionClient } from "./src/models/search-projection/search-projection-client";
+import { ILivingCost } from "./src/models/bestfit-programme/i-living-cost";
+import { IGPARequirement } from "./src/models/common/i-g-p-a-requirement";
+import { IBestFitProgramme } from "./src/models/bestfit-programme/i-best-fit-programme";
+import { BestfitProgrammeClient } from "./src/models/bestfit-programme/bestfit-programme-client";
+import { ILogo } from "./src/models/common/i-logo";
+import { ITuitionFee } from "./src/models/common/i-tuition-fee";
+import { IEnglishRequirements } from "./src/models/common/i-english-requirements";
+import { IInternalLink } from "./src/models/dotdigital-programme/i-internal-link";
+import { IDotDigitalProgramme } from "./src/models/dotdigital-programme/i-dot-digital-programme";
+import { DotdigitalProgrammeClient } from "./src/models/dotdigital-programme/dotdigital-programme-client";
+import { ISitemapProgrammeInfo } from "./src/models/sitemap-programme-info/i-sitemap-programme-info";
+import { SitemapProgrammeInfoClient } from "./src/models/sitemap-programme-info/sitemap-programme-info-client";
+import { ISearchCountryFaq } from "./src/models/search-country-faq/i-search-country-faq";
+import { PublicSearchCountryFaqClient } from "./src/models/search-country-faq/public-search-country-faq-client";
+import { ISitemapCountryInfo } from "./src/models/sitemap-countries-info/i-sitemap-country-info";
+import { SitemapCountriesInfoClient } from "./src/models/sitemap-countries-info/sitemap-countries-info-client";
+import { IDegreeInfo } from "./src/models/sitemap-country-degree-info/i-degree-info";
+import { ISitemapCountryDegreeInfo } from "./src/models/sitemap-country-degree-info/i-sitemap-country-degree-info";
+import { SitemapCountryDegreeInfoClient } from "./src/models/sitemap-country-degree-info/sitemap-country-degree-info-client";
+import { ISearchDiscipline } from "./src/models/search-discipline/i-search-discipline";
+import { PublicSearchDisciplineClient } from "./src/models/search-discipline/public-search-discipline-client";
+import { ISitemapDisciplineInfo } from "./src/models/sitemap-disciplines-info/i-sitemap-discipline-info";
+import { SitemapDisciplinesInfoClient } from "./src/models/sitemap-disciplines-info/sitemap-disciplines-info-client";
+import { ICountry } from "./src/models/common/i-country";
+import { ICity } from "./src/models/common/i-city";
+import { IReview } from "./src/models/dotdigital-organisation/i-review";
+import { IDotDigitalOrganisation } from "./src/models/dotdigital-organisation/i-dot-digital-organisation";
+import { DotdigitalOrganisationClient } from "./src/models/dotdigital-organisation/dotdigital-organisation-client";
+import { ISitemapOrganisationInfo } from "./src/models/sitemap-organisations-info/i-sitemap-organisation-info";
+import { SitemapOrganisationsInfoClient } from "./src/models/sitemap-organisations-info/sitemap-organisations-info-client";
+import { ISitemapRankingsInfo } from "./src/models/sitemap-rankings-info/i-sitemap-rankings-info";
+import { SitemapRankingsInfoClient } from "./src/models/sitemap-rankings-info/sitemap-rankings-info-client";
+import { ISitemapArticleInfo } from "./src/models/sitemap-articles-info/i-sitemap-article-info";
+import { SitemapArticlesInfoClient } from "./src/models/sitemap-articles-info/sitemap-articles-info-client";
+import { ISitemapCityInfo } from "./src/models/sitemap-cities-info/i-sitemap-city-info";
+import { SitemapCitiesInfoClient } from "./src/models/sitemap-cities-info/sitemap-cities-info-client";
+import { IScholarshipCard } from "./src/models/scholarship-card/i-scholarship-card";
+import { PublicScholarshipCardClient } from "./src/models/scholarship-card/public-scholarship-card-client";
+import { IRankingCards } from './src/models/ranking-cards/i-ranking-cards';
+import { IRankingCard } from './src/models/ranking-cards/i-ranking-card';
+import { IRanking } from './src/models/ranking-cards/i-ranking';
+import { PublicRankingCardsClient } from './src/models/ranking-cards/public-ranking-cards-client';
+import { PortalType } from "./src/types/portal-type";
+import { PortalMap } from "./src/types/portal-map";
+import { ModelClient } from "./src/model-client";
+import { ICompareProgramme } from "./src/models/compare-programme/i-compare-programme"
+import { CompareProgrammeClient } from "./src/models/compare-programme/compare-programme-client"
+
+export {
+	BadRequestException,
+	ClientException,
+	InternalServerException,
+	NotFoundException,
+	PropertyNotAvailableException,
+	ICover,
+	ILink,
+	IOptionalLink,
+	ILocation,
+	IClickTrackingData,
+	ITracking,
+	IDuration,
+	IDeadline,
+	IStartDate,
+	ITiming,
+	ITrackedLink,
+	IProgrammeCard,
+	ProgrammeCardClient,
+	ITuitionValues,
+	IPremiumValues,
+	IOrganisationValues,
+	IGeoTargetingConfiguration,
+	IGeoTargetingValues,
+	ISearchProjection,
+	SearchProjectionClient,
+	ILivingCost,
+	IGPARequirement,
+	IBestFitProgramme,
+	BestfitProgrammeClient,
+	ILogo,
+	ITuitionFee,
+	IEnglishRequirements,
+	IInternalLink,
+	IDotDigitalProgramme,
+	DotdigitalProgrammeClient,
+	ISitemapProgrammeInfo,
+	SitemapProgrammeInfoClient,
+	ISearchCountryFaq,
+	PublicSearchCountryFaqClient,
+	ISitemapCountryInfo,
+	SitemapCountriesInfoClient,
+	IDegreeInfo,
+	ISitemapCountryDegreeInfo,
+	SitemapCountryDegreeInfoClient,
+	ISearchDiscipline,
+	PublicSearchDisciplineClient,
+	ISitemapDisciplineInfo,
+	SitemapDisciplinesInfoClient,
+	ICountry,
+	ICity,
+	IReview,
+	IDotDigitalOrganisation,
+	DotdigitalOrganisationClient,
+	ISitemapOrganisationInfo,
+	SitemapOrganisationsInfoClient,
+	ISitemapRankingsInfo,
+	SitemapRankingsInfoClient,
+	ISitemapArticleInfo,
+	SitemapArticlesInfoClient,
+	ISitemapCityInfo,
+	SitemapCitiesInfoClient,
+	IScholarshipCard,
+	PublicScholarshipCardClient,
+	IRankingCards,
+	IRankingCard,
+	IRanking,
+	PublicRankingCardsClient,
+	ICompareProgramme,
+	CompareProgrammeClient,
+	PortalType,
+	PortalMap,
+	ModelClient
+}

package/package.json

@@ -1,55 +1,55 @@
-{
-  "name": "@studyportals/domain-client",
-  "version": "3.17.1",
-  "description": "Responsible for fetching data from the Domain API",
-  "main": "bin/index.js",
-  "author": "StudyPortals B.V.",
-  "contributors": [
-    "braaibander <danny@studyportals.com>"
-  ],
-  "license": "BSD-3-Clause",
-  "scripts": {
-    "test": "mocha --reporter spec \"tests/**/*.test.ts\"",
-    "coverage": "nyc mocha --reporter dot \"tests/**/*.test.ts\"",
-    "lint": "eslint . --ext .ts --max-warnings=0",
-    "lint:fix": "eslint . --ext .ts --fix",
-    "pre-push": "npm run test && npm run coverage && npm run lint",
-    "prepare-dist": "npm run test  && rm -fR bin && npx tsc && cp package.json bin/package.json && rm -fR bin/tests",
-    "publish-beta": "npm version prerelease --preid=beta && npm run prepare-dist && npm publish ./bin --tag beta",
-    "publish-major": "npm version major && npm run prepare-dist && npm publish ./bin",
-    "publish-minor": "npm version minor && npm run prepare-dist && npm publish ./bin",
-    "publish-patch": "npm version patch && npm run prepare-dist && npm publish ./bin",
-    "publish-current": "npm run prepare-dist && npm publish ./bin"
-  },
-  "husky": {
-    "hooks": {
-      "pre-push": "npm run pre-push"
-    }
-  },
-  "dependencies": {
-    "axios": "^0.21.0"
-  },
-  "devDependencies": {
-    "@studyportals/code-style": "^1.8.1",
-    "@testdeck/mocha": "^0.3.3",
-    "@types/axios": "^0.14.0",
-    "@types/mocha": "^10.0.0",
-    "@types/moxios": "^0.4.9",
-    "@types/node": "^14.14.8",
-    "@types/reflect-metadata": "^0.1.0",
-    "@typescript-eslint/eslint-plugin": "^4.8.1",
-    "@typescript-eslint/parser": "^4.8.1",
-    "eslint": "^7.13.0",
-    "eslint-plugin-import": "^2.22.1",
-    "eslint-plugin-mocha": "^10.1.0",
-    "husky": "^4.3.0",
-    "mocha": "^10.1.0",
-    "moxios": "^0.4.0",
-    "nyc": "^15.1.0",
-    "source-map-support": "^0.5.19",
-    "ts-node": "^10.9.1",
-    "tslint": "^6.1.3",
-    "typemoq": "^2.1.0",
-    "typescript": "^4.9.3"
-  }
-}
+{
+  "name": "@studyportals/domain-client",
+  "version": "3.18.0",
+  "description": "Responsible for fetching data from the Domain API",
+  "main": "bin/index.js",
+  "author": "StudyPortals B.V.",
+  "contributors": [
+    "braaibander <danny@studyportals.com>"
+  ],
+  "license": "BSD-3-Clause",
+  "scripts": {
+    "test": "mocha --reporter spec \"tests/**/*.test.ts\"",
+    "coverage": "nyc mocha --reporter dot \"tests/**/*.test.ts\"",
+    "lint": "eslint . --ext .ts --max-warnings=0",
+    "lint:fix": "eslint . --ext .ts --fix",
+    "pre-push": "npm run test && npm run coverage && npm run lint",
+    "prepare-dist": "npm run test  && rm -fR bin && npx tsc && cp package.json bin/package.json && rm -fR bin/tests",
+    "publish-beta": "npm version prerelease --preid=beta && npm run prepare-dist && npm publish ./bin --tag beta",
+    "publish-major": "npm version major && npm run prepare-dist && npm publish ./bin",
+    "publish-minor": "npm version minor && npm run prepare-dist && npm publish ./bin",
+    "publish-patch": "npm version patch && npm run prepare-dist && npm publish ./bin",
+    "publish-current": "npm run prepare-dist && npm publish ./bin"
+  },
+  "husky": {
+    "hooks": {
+      "pre-push": "npm run pre-push"
+    }
+  },
+  "dependencies": {
+    "axios": "^0.21.0"
+  },
+  "devDependencies": {
+    "@studyportals/code-style": "^1.8.1",
+    "@testdeck/mocha": "^0.3.3",
+    "@types/axios": "^0.14.0",
+    "@types/mocha": "^10.0.0",
+    "@types/moxios": "^0.4.9",
+    "@types/node": "^14.14.8",
+    "@types/reflect-metadata": "^0.1.0",
+    "@typescript-eslint/eslint-plugin": "^4.8.1",
+    "@typescript-eslint/parser": "^4.8.1",
+    "eslint": "^7.13.0",
+    "eslint-plugin-import": "^2.22.1",
+    "eslint-plugin-mocha": "^10.1.0",
+    "husky": "^4.3.0",
+    "mocha": "^10.1.0",
+    "moxios": "^0.4.0",
+    "nyc": "^15.1.0",
+    "source-map-support": "^0.5.19",
+    "ts-node": "^10.9.1",
+    "tslint": "^6.1.3",
+    "typemoq": "^2.1.0",
+    "typescript": "^4.9.3"
+  }
+}

package/src/domain-client.ts

@@ -0,0 +1,70 @@
+import Axios, { AxiosRequestConfig } from "axios";
+
+import { BadRequestException } from "./exceptions/bad-request-exception";
+import { InternalServerException } from "./exceptions/internal-server-exception";
+import { NotFoundException } from "./exceptions/not-found-exception";
+import { IApiResponse } from "./i-api-response";
+import { IModelDescription } from "./i-model-description";
+
+
+export class DomainClient {
+
+	constructor(
+		public readonly baseUrl: string,
+		public readonly apiKey: string | undefined,
+		public readonly model: string,
+		public readonly version: string,
+		public readonly isPublic: boolean,
+		public readonly seed: number
+	) {
+	}
+
+	public async doRequest(ids: number[]): Promise<IModelDescription[]> {
+		const url = this.buildUrl(ids);
+		const config: AxiosRequestConfig = { baseURL: this.baseUrl	}
+		if (this.apiKey !== undefined) {
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+			config["headers"] = {'x-api-key': this.apiKey}
+		}
+		const axiosResponse = await Axios.get(url, config);
+		const response = axiosResponse.data as IApiResponse;
+		this.handleErrors(response);
+
+		const models: IModelDescription[] = [];
+		for (const id of ids) {
+			const modelData = response.data[id];
+			if (!modelData) {
+				continue;
+			}
+			models.push(modelData);
+		}
+		return models;
+	}
+
+	private handleErrors(response: IApiResponse): void {
+		if (!response.status) {
+			throw new InternalServerException(response.message);
+		}
+
+		if (response.status === 400) {
+			throw new BadRequestException(response.message);
+		}
+
+		if (response.status === 404) {
+			throw new NotFoundException(response.message);
+		}
+	}
+
+	private buildUrl(ids: number[]): string {
+		const publicPrefix = this.shouldAddPublicPrefix() ? 'public/' : '';
+		let query = `${publicPrefix}${this.model}/${this.version}/?seed=${this.seed}`;
+		for (const id of ids) {
+			query += `&id=${id}`;
+		}
+		return query;
+	}
+
+	private shouldAddPublicPrefix(): boolean {
+		return this.isPublic && this.apiKey === undefined;
+	}
+}

package/src/exceptions/bad-request-exception.ts

@@ -0,0 +1,2 @@
+export class BadRequestException extends Error {
+}

package/src/exceptions/client-exception.ts

@@ -0,0 +1,2 @@
+export class ClientException extends Error {
+}

package/src/exceptions/internal-server-exception.ts

@@ -0,0 +1,2 @@
+export class InternalServerException extends Error {
+}

package/src/exceptions/not-found-exception.ts

@@ -0,0 +1,2 @@
+export class NotFoundException extends Error {
+}

package/src/exceptions/property-not-available-exception.ts

@@ -0,0 +1,2 @@
+export class PropertyNotAvailableException extends Error {
+}

package/src/factories/DateFactory.ts

@@ -0,0 +1,8 @@
+import { IClassFactory } from "../i-class-factory";
+import { CallableReturnType, Model } from "../types";
+
+export class DateFactory implements IClassFactory {
+	public create(data: Model, parameters: string[]): CallableReturnType {
+		return new Date(parameters[0]);
+	}
+}

package/src/factories/InternalLinkFactory.ts

@@ -0,0 +1,27 @@
+import { IClassFactory } from "../i-class-factory";
+import { PortalType } from "../types/portal-type";
+import { CallableReturnType, Model } from "../types";
+import { PortalMap } from "../types/portal-map";
+
+export class InternalLinkFactory implements IClassFactory {
+	private portalMap: PortalMap;
+
+	constructor(portalMap: PortalMap) {
+		this.portalMap = portalMap;
+	}
+
+	public create(link: Model): CallableReturnType {
+		const portalBaseUrl = this.getPortalBaseUrl(link.getPortalType() as PortalType);
+
+		const path = link['getUrl']() as string;
+		link['getUrl'] = (): string => portalBaseUrl + path;
+
+		return link;
+	}
+
+	private getPortalBaseUrl(portalType: PortalType): string {
+		const url = this.portalMap.get(portalType);
+		return url || '';
+	}
+
+}

package/src/i-api-response.ts

@@ -0,0 +1,7 @@
+import { IModelDescription } from "./i-model-description";
+
+export interface IApiResponse {
+	status: number;
+	data: Record<number, IModelDescription>;
+	message: string
+}

package/src/i-class-factory.ts

@@ -0,0 +1,5 @@
+import { CallableReturnType, Model } from "./types";
+
+export interface IClassFactory {
+	create(data: Model, parameters?: any[]): CallableReturnType
+}

package/src/i-model-description.ts

@@ -0,0 +1,13 @@
+import { AcceptedType } from "./types";
+
+export interface IModelDescription {
+	class: string;
+	func: Record<string, AcceptedType | IModelDescription>;
+	parameters?: any[];
+}
+
+// eslint-disable-next-line
+export function isModelDescription(arg: any): arg is IModelDescription {
+	// eslint-disable-next-line
+	return arg && arg.class && (arg.func || arg.parameters);
+}

package/src/model-client.ts

@@ -0,0 +1,77 @@
+import { DomainClient } from "./domain-client";
+import { ClientException } from "./exceptions/client-exception";
+import { IModelDescription } from "./i-model-description";
+import { ModelFactory } from "./model-factory";
+import { PortalMap } from "./types/portal-map";
+
+
+export abstract class ModelClient<T> {
+	private readonly domainClient: DomainClient | null;
+	private readonly modelFactory: ModelFactory<T>;
+
+	constructor(
+		baseUrl?: string,
+		apiKey?: string,
+		seed?: number,
+		portalMap?: PortalMap
+	) {
+		if (!baseUrl || !seed) {
+			return;
+		}
+
+		this.modelFactory = new ModelFactory<T>(portalMap);
+		this.domainClient = new DomainClient(
+			baseUrl,
+			apiKey,
+			this.getModelName(),
+			this.getVersion(),
+			this.isPublic(),
+			seed
+		);
+	}
+
+	public async fetch(id: number): Promise<T> {
+		const modelDescriptions = await this.fetchDescription(id);
+		return this.modelFactory.fromDescription(modelDescriptions);
+	}
+
+	public async fetchDescription(id: number): Promise<IModelDescription> {
+		if (!this.domainClient) {
+			throw new ClientException(
+				"Offline mode active: did you provide all parameters " +
+				"in the constructor?"
+			);
+		}
+		const result = await this.domainClient.doRequest([id]);
+		return result[0];
+	}
+
+	public async fetchMultiple(ids: number[]): Promise<T[]> {
+		const descriptions = await this.fetchMultipleDescriptions(ids);
+		return this.modelFactory.fromDescriptions(descriptions);
+	}
+
+	public async fetchMultipleDescriptions(ids: number[]): Promise<IModelDescription[]> {
+		if (!this.domainClient) {
+			throw new ClientException(
+				'Offline mode active: did you provide all parameters ' +
+				'in the constructor?'
+			);
+		}
+		return await this.domainClient.doRequest(ids);
+	}
+
+	public fromDescription(description: IModelDescription): T {
+		return this.modelFactory.fromDescription(description);
+	}
+
+	public fromDescriptions(descriptions: IModelDescription[]): T[] {
+		return this.modelFactory.fromDescriptions(descriptions);
+	}
+
+	protected abstract getModelName(): string;
+
+	protected abstract getVersion(): string;
+
+	public abstract isPublic(): boolean;
+}

package/src/model-factory.ts

@@ -0,0 +1,94 @@
+import { InternalLinkFactory } from "./factories/InternalLinkFactory";
+import { DateFactory } from "./factories/DateFactory";
+import { IClassFactory } from "./i-class-factory";
+import { IModelDescription, isModelDescription } from "./i-model-description";
+import { PropertyNotAvailableException } from "./exceptions/property-not-available-exception";
+import { Callable, CallableReturnType, Model } from "./types";
+import { PortalMap } from "./types/portal-map";
+import { PortalType } from "./types/portal-type";
+
+export class ModelFactory<T> {
+
+	private customClassFactories: Map<string, IClassFactory>;
+
+	constructor(portalMap: PortalMap = new Map<PortalType, string>()) {
+		const factories = new Map<string, IClassFactory>();
+		factories.set('IInternalLink', new InternalLinkFactory(portalMap));
+		factories.set('SerializableDateTime', new DateFactory());
+
+		this.customClassFactories = factories;
+	}
+
+	public fromDescription(data: IModelDescription): T {
+		return this.unpackClass(data) as unknown as T;
+	}
+
+	public fromDescriptions(data: IModelDescription[]): T[] {
+		const models: T[] = [];
+		for (const modelDescription of data) {
+			models.push(this.unpackClass(modelDescription) as unknown as T);
+		}
+		return models;
+	}
+
+	private unpackClass(data: IModelDescription): CallableReturnType {
+
+
+		const unpacked: Model = {};
+		for (const functionName in data.func) {
+			unpacked[functionName] = this.getCallable(functionName, data);
+		}
+
+		const factory = this.customClassFactories.get(data.class);
+		if (factory !== undefined) {
+			return factory.create(unpacked, data.parameters);
+		}
+
+		return unpacked;
+	}
+
+	private getCallable(
+		functionName: string,
+		data: IModelDescription
+	): Callable {
+		const propertyName = functionName.substr(3);
+		const canShowFunction = 'canShow' + propertyName;
+
+		const value: unknown = data.func[functionName];
+		let returnValue: CallableReturnType|CallableReturnType[];
+
+		if (isModelDescription(value)) {
+			returnValue = this.unpackClass(value);
+		} else if (Array.isArray(value)) {
+			returnValue = this.unpackArray(value);
+		} else {
+			returnValue = value as CallableReturnType;
+		}
+
+		if (canShowFunction in data.func) {
+			return (): any => {
+				if (data.func[canShowFunction] === false) {
+					throw new PropertyNotAvailableException(
+						`Property '${propertyName}' not available`
+					);
+				}
+				return returnValue;
+			};
+		}
+		return (): any => {
+			return returnValue;
+		};
+	}
+
+	private unpackArray(list: any[]): CallableReturnType[] {
+		return list.map(
+			item => {
+				if (isModelDescription(item)) {
+					return this.unpackClass(item)
+				}
+
+				return item as CallableReturnType;
+			}
+		);
+	}
+}

package/src/models/bestfit-programme/bestfit-programme-client.ts

@@ -0,0 +1,16 @@
+import { IBestFitProgramme } from "../../..";
+import { ModelClient } from "../../model-client";
+
+export class BestfitProgrammeClient extends ModelClient<IBestFitProgramme> {
+	protected getModelName(): string {
+		return 'bestfit-programme';
+	}
+
+	protected getVersion(): string {
+		return 'v1';
+	}
+
+	public isPublic(): boolean {
+		return false;
+	}
+}