@studyportals/cors 2.8.0 → 2.8.1-alpha.0

package/.codeclimate.yml

@@ -0,0 +1,25 @@
+engines:
+  duplication:
+    enabled: true
+    config:
+      languages:
+      - ruby:
+      - javascript:
+      - php:
+      - python:
+  eslint:
+    enabled: true
+    # 5.7.0
+    channel: "eslint-5"
+  tslint:
+    enabled: true
+    # 5.9.1
+    config: tslint.json
+  fixme:
+    enabled: true
+ratings:
+  paths:
+    - "**.js"
+    - "**.ts"
+exclude_paths:
+   - "**/node_modules/"

package/.github/CODEOWNERS

@@ -0,0 +1 @@
+* @studyportals/plop @studyportals/samurai-pizza-cats

package/.nycrc

@@ -0,0 +1,22 @@
+{
+ "include": [
+   "src/**/*.ts"
+ ],
+ "exclude": [
+   "src/**/*.interface.ts"
+ ],
+ "require": [
+   "ts-node/register"
+ ],
+ "extension": [
+   ".ts"
+ ],
+ "reporter": [
+   "lcov",
+   "text-summary",
+   "html"
+ ],
+ "sourceMap": true,
+ "instrument": true,
+ "all": false
+}

package/.travis.yml

@@ -0,0 +1,18 @@
+env:
+  global:
+    - CC_TEST_REPORTER_ID=81a49eda82f1c6ca2bcaf8475befb5a95136032496a53d6754f5e657d8c56a48
+language: node_js
+node_js:
+  - "8"
+cache:
+  npm: true # this cashes ~/.npm folder on Travis
+install:
+  - npm ci
+script:
+  - npm run test:coverage
+before_script:
+  - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
+  - chmod +x ./cc-test-reporter
+  - ./cc-test-reporter before-build
+after_script:
+  - ./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT

package/README.md

@@ -0,0 +1,110 @@
+![volkswagen status](https://auchenberg.github.io/volkswagen/volkswargen_ci.svg?v=1)
+# CORS
+
+# Getting Started
+
+This library can be used to add CORS validation to your API. It can also replace API gateway's implementation of CORS by adding an OPTIONS lambda. This is necessary when you API needs to function for wildcard domains like release candidates.
+
+## Installation
+
+```bash
+npm install @studyportals/cors
+```
+
+## Setting up the CORS check in your repo
+To use this package in a Lambda the CORS class needs to be constructed outside of the lambda handler. Example:
+
+```typescript
+import {CORS, Scope, Environment} from '@studyportals/cors'
+
+const cors = new CORS(Scope.Student, Environment.Production)
+
+export async function handler(event: any) {
+    const response = {body: 'someBody', headers: {}};
+    const origin = event.headers['Origin']; // BEAWARE HEADERS ARE CASE SENSITIVE!!
+    
+    if(await cors.isValidDomain(origin)){
+        response.headers['Access-Control-Allow-Origin'] = origin;
+    }
+    
+    return response;
+}
+
+```
+
+Make sure to use the correct `Scope` And `Environment`
+
+The lambda needs to have access to these buckets. If this bucket is not in your account you need to ask `Samurai Pizza Cats` for access.
+
+## Setting up the Options lambda.
+To add the OPTIONS lambda you need to make sure all lambda's have CORS disabled. After this you can create a lambda using the following snippet:
+
+```typescript
+import {OptionsLambda, Scope, Environment} from '@studyportals/cors'
+
+const optionsLambda = new OptionsLambda(Scope.Student, Environment.Production);
+const handler = optionsLambda.getHandler();
+
+// Lambda hook
+export function handler;
+```
+
+This lambda handler needs to be added to the `serverless.yaml` file. The incoming event needs to be a http event with the path `/{any+}` and method `OPTIONS`
+
+
+## Express CORS
+Express applications can use the `ExpressMiddleware` provided by this package. Example:  
+```typescript
+import { express } from 'express';
+import {ExpressMiddleware, Scope, Environment} from '@studyportals/cors'
+const app = express();
+
+const corsMiddleWare = ExpressMiddleware.getMiddleWare(Scope.Student, Environment.Production);
+app.use(corsMiddleWare);
+```
+
+## S3 CORS rules
+[GoldenEye](https://github.com/studyportals/goldeneye) and other tools that need to generate S3 IAM policies can use the `S3Rules` provided in this package. Example:  
+```typescript
+import { CorsRule } from "aws-cdk-lib/aws-s3";
+import * as cors from "@studyportals/cors";
+
+generateRules = (scope: cors.Scope, environment: cors.Environment): CorsRule[] => {
+		return cors.S3Rules.generate(scope, environment) as CorsRule[];
+	};
+```
+
+
+# Developing the package
+
+## Modifying allowed domain list
+When modifying the allowed domain list follow the following rules
+
+1. When a domain is added or removed for security reasons (Unauthorized access by thirdparty) the major version should be increased. All microservices need to update their version of this package ASAP.
+
+2. When a domain is added for feature reasons (Added another micro website) the minor version should be increased. Only affected microservices should be required to update their CORS package ASAP
+
+## Compiling
+In a terminal, run 
+```
+tsc
+```
+
+The output JavaScript can be found in `/bin`.
+
+## Testing
+
+Run `npm test` to execute the unit tests.
+
+run `npm test:coverage` to run the unit tests as well as generate a coverage report.
+
+If `test` fails, publishing will not continue. 
+Consult the terminal to find out why this has happened.
+
+We have a reference document for writing tests [here](https://github.com/studyportals/SamuraiPizzaCats/blob/master/Testing.md "SamuraiPizzaCats/Testing.md"). 
+
+## Deploying
+We publish an npm package, this is done by first committing and pushing the changes. updating the version number, followed by a `npm run deploy` command. This command prepares for deployment and then automatically publishes and pushes to GitHub.
+
+# House Rules
+House Rules are located in the [SamuraiPizzaCats](https://github.com/studyportals/SamuraiPizzaCats) repository.

package/bin/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@studyportals/cors",
+  "version": "2.8.1",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "mocha test/**/*.test.ts",
+    "test:watch": "mocha -w --reporter min test/**/*.test.ts",
+    "deploy-patch": "npm version patch && npm run deploy",
+    "deploy-minor": "npm version minor && npm run deploy",
+    "deploy-major": "npm version major && npm run deploy",
+    "prepare-deployment": "cp package.json bin/package.json",
+    "deploy": "npm run build && npm run prepare-deployment && npm publish ./bin",
+    "build": "rm -rf bin && tsc && rm -rf bin/test",
+    "lint": "tslint 'src/**/*.ts'",
+    "lint-fix": "tslint --fix 'src/**/*.ts'",
+    "test:coverage": "nyc mocha test/**/*.test.ts"
+  },
+  "private": false,
+  "author": "SP - Samurai Pizza Cats",
+  "license": "BSD3",
+  "dependencies": {
+    "@types/express": "^4.17.3"
+  },
+  "devDependencies": {
+    "@types/chai": "^4.1.7",
+    "@types/node": "^10.12.15",
+    "chai": "^4.2.0",
+    "mocha": "^5.2.0",
+    "mocha-typescript": "1.1.12",
+    "nyc": "^13.3.0",
+    "ts-loader": "^2.3.7",
+    "ts-node": "^7.0.1",
+    "tslint": "^5.11.0",
+    "typemoq": "^2.1.0",
+    "typescript": "^4.8.4"
+  }
+}

package/{src → bin/src}/domain/allowed-explicit-domains-rules.js

@@ -33,10 +33,7 @@ exports.AllowedExplicitDomainsRules = {
             maxAge: 3000
         },
         [environment_1.Environment.Testing]: {
-            allowedOrigins: ["*-uniadmin.prtl.fyi",
-                "*.administration.tst.studyportals.eu", "administration.tst.studyportals.eu",
-                "https://administration.dev.studyportals.eu:*",
-                "*-uniadmin.studyportals.eu"],
+            allowedOrigins: ["*.studyportals.eu"],
             allowedMethods: ["GET"],
             allowedHeaders: ["*"],
             exposedHeaders: [],

package/index.ts

@@ -0,0 +1,2 @@
+export * from './src/domain';
+export * from './src/implementations';

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@studyportals/cors",
-  "version": "2.8.0",
+  "version": "2.8.1-alpha.0",
   "description": "",
-  "main": "bin/index.js",
+  "main": "index.js",
   "scripts": {
     "test": "mocha test/**/*.test.ts",
     "test:watch": "mocha -w --reporter min test/**/*.test.ts",
@@ -35,4 +35,4 @@
     "typemoq": "^2.1.0",
     "typescript": "^4.8.4"
   }
-}
+}

package/src/domain/allowed-domain-reg-ex-list.ts

@@ -0,0 +1,28 @@
+import { Environment } from './enums/environment';
+import { Scope } from './enums/scope';
+
+export const AllowedDomainRegExList = {
+	[Scope.Student]: {
+		[Environment.Production]: [
+			/^https?:\/\/(www(?:\.dev)?|cypress\.rc|rc|beta|[0-9]{4,16}(?:-bob)?\.rc)\.mastersportal\.(com|fyi)(?::3030)?$/,
+			/^https?:\/\/(www(?:\.dev)?|cypress\.rc|rc|beta|[0-9]{4,16}(?:-bob)?\.rc)\.bachelorsportal\.(com|fyi)(?::3030)?$/,
+			/^https?:\/\/(www(?:\.dev)?|cypress\.rc|rc|beta|[0-9]{4,16}(?:-bob)?\.rc)\.phdportal\.(com|fyi)(?::3030)?$/,
+			/^https?:\/\/(www(?:\.dev)?|cypress\.rc|rc|beta|[0-9]{4,16}(?:-bob)?\.rc)\.preparationcoursesportal\.(com|fyi)(?::3030)?$/,
+			/^https?:\/\/(www(?:\.dev)?|cypress\.rc|rc|beta|[0-9]{4,16}(?:-bob)?\.rc)\.distancelearningportal\.(com|fyi)(?::3030)?$/,
+			/^https?:\/\/(www(?:\.dev)?|cypress\.rc|rc|beta|[0-9]{4,16}(?:-bob)?\.rc)\.shortcoursesportal\.(com|fyi)(?::3030)?$/,
+			/^https?:\/\/(www.)?admissiontestportal.com?$/,
+			/^https?:\/\/studentemailing\.prtl\.co$/,
+			/^https?:\/\/scholarship\.mastersportal\.com$/,
+			/^https?:\/\/students\.mastersportal\.com$/,
+			/^https?:\/\/search-page\.prtl\.co$/,
+			/^https?:\/\/reviews\.studyportals\.com$/,
+		],
+		[Environment.Testing]: [
+			/(.*?)/,
+		],
+	},
+	[Scope.UniAdmin]: {
+		[Environment.Production]: [/(.*?)/],
+		[Environment.Testing]: [/(.*?)/],
+	},
+};

package/src/domain/allowed-explicit-domains-rules.ts

@@ -0,0 +1,53 @@
+import { Environment } from "./enums/environment";
+import { Scope } from "./enums/scope";
+
+export type AllowedExplicitDomainsRulesType = typeof AllowedExplicitDomainsRules
+
+export type CorsRule = {
+	allowedOrigins: string[],
+	allowedMethods: string[],
+	allowedHeaders: string[],
+	exposedHeaders: string[],
+	maxAge: number,
+}
+
+export const AllowedExplicitDomainsRules = {
+	[Scope.Student]: {
+		[Environment.Production]: {
+			allowedOrigins: ["*.mastersportal.com", "*.bachelorsportal.com", "*.shortcoursesportal.com",
+				"*.distancelearningportal.com", "*.preparationcoursesportal.com", "*.phdportal.com",
+				"*.prtl.co", "*.rc.mastersportal.fyi", "*.rc.bachelorsportal.fyi", "*.rc.shortcoursesportal.fyi",
+				"*.rc.distancelearningportal.fyi", "*.rc.preparationcoursesportal.fyi", "*.rc.phdportal.fyi",
+				"*.admissiontestportal.com", "https://admissiontestportal.com", "*.studyportals.com"],
+			allowedHeaders: ["Authorization"],
+			allowedMethods: ["GET"],
+			exposedHeaders: [],
+			maxAge: 3000
+
+		},
+		[Environment.Testing]: {
+			allowedOrigins: ["*"],
+			allowedMethods: ["GET"],
+			allowedHeaders: ["Authorization"],
+			exposedHeaders: [],
+			maxAge: 3000
+		}
+	},
+	[Scope.UniAdmin]: {
+		[Environment.Production]: {
+			allowedOrigins: ["*.studyportals.eu"],
+			allowedHeaders: ["Authorization"],
+			allowedMethods: ["GET", "POST"],
+			exposedHeaders: [],
+			maxAge: 3000
+
+		},
+		[Environment.Testing]: {
+			allowedOrigins: ["*.studyportals.eu"],
+			allowedMethods: ["GET"],
+			allowedHeaders: ["*"],
+			exposedHeaders: [],
+			maxAge: 3000
+		}
+	}
+};

package/src/domain/cors.ts

@@ -0,0 +1,32 @@
+import { AllowedDomainRegExList } from './allowed-domain-reg-ex-list';
+import { AllowedExplicitDomainsRules, CorsRule } from './allowed-explicit-domains-rules';
+import { Environment } from './enums/environment';
+import { Scope } from './enums/scope';
+
+export class CORS {
+
+	private regExes: RegExp[];
+	private s3Rules: CorsRule[]
+
+	constructor(scope: Scope, environment: Environment = Environment.Production) {
+		this.regExes = AllowedDomainRegExList[scope][environment];
+		this.s3Rules = [ AllowedExplicitDomainsRules[scope][environment] ] ;
+	}
+
+	/**
+	 * isValidDomain
+	 */
+	public async isValidDomain(domain: string): Promise<boolean> {
+		const hasMatch = this.regExes.filter((regex) => domain.match(regex) !== null);
+		return (hasMatch.length !== 0);
+
+	}
+
+	/**
+	 * getIamRules
+	 */
+	public getS3Rules(): CorsRule[] {
+		return this.s3Rules;
+	}
+
+}

package/src/domain/enums/environment.ts

@@ -0,0 +1,4 @@
+export enum Environment {
+	Production,
+	Testing,
+}

package/src/domain/enums/index.ts

@@ -0,0 +1,2 @@
+export * from './environment';
+export * from './scope';

package/src/domain/enums/scope.ts

@@ -0,0 +1,4 @@
+export enum Scope {
+	Student,
+	UniAdmin
+}

package/src/domain/index.ts

@@ -0,0 +1,3 @@
+export * from './cors';
+export * from './allowed-domain-reg-ex-list';
+export * from './enums';

package/src/implementations/express-middleware.ts

@@ -0,0 +1,21 @@
+import { NextFunction, Request, RequestHandler, Response } from 'express';
+import { CORS } from '../domain';
+import { Environment, Scope } from '../domain/enums';
+
+export class ExpressMiddleware {
+
+	public static getMiddleWare(scope: Scope, environment: Environment = Environment.Production): RequestHandler {
+		const cors = new CORS(scope, environment);
+
+		return async (req: Request, res: Response, next: NextFunction) => {
+			const origin = req.get('origin') || '';
+
+			if (await cors.isValidDomain(origin)) {
+				res.header('Access-Control-Allow-Origin', origin);
+			}
+
+			next();
+		};
+
+	}
+}

package/src/implementations/index.ts

@@ -0,0 +1,3 @@
+export * from './options';
+export * from './express-middleware';
+export * from './s3-rules';

package/src/implementations/options.ts

@@ -0,0 +1,50 @@
+'use strict';
+
+import {CORS} from '../domain';
+import { Environment, Scope } from '../domain/enums';
+
+export class OptionsLambda {
+	private cors: CORS;
+
+	constructor(scope: Scope, environment: Environment = Environment.Production) {
+		this.cors = new CORS(scope, environment);
+	}
+
+	getLowercasedHeaders(event: any): any {
+		const headers = {};
+
+		Object.keys(event.headers).forEach((key) => {
+			headers[key.toLowerCase()] = event.headers[key];
+		});
+
+		return headers;
+	}
+
+	getOrigin(event: any): string {
+		const headers = this.getLowercasedHeaders(event);
+		return headers['origin'];
+	}
+
+	getHandler(): (event: any) => Promise<any> {
+		return async (event) => {
+
+			const origin = this.getOrigin(event);
+			const headers = {
+				'Cache-Control': 'max-age=600, s-maxage=600, proxy-revalidate',
+			};
+
+			if (await this.cors.isValidDomain(origin)) {
+				headers['Access-Control-Allow-Origin'] = origin;
+				headers['Access-Control-Allow-Headers'] = 'authorization, x-api-key, content-type';
+				headers['Access-Control-Allow-Methods'] = 'GET, POST, DELETE, PATCH, HEAD, PUT, OPTIONS';
+				headers['Access-Control-Max-Age'] = '600';
+			}
+
+			return {
+				statusCode: 200,
+				headers,
+			};
+		};
+	}
+
+}

package/src/implementations/s3-rules.ts

@@ -0,0 +1,12 @@
+import { NextFunction, Request, RequestHandler, Response } from 'express';
+import { CORS } from '../domain';
+import { AllowedExplicitDomainsRulesType, CorsRule } from '../domain/allowed-explicit-domains-rules';
+import { Environment, Scope } from '../domain/enums';
+
+export class S3Rules {
+
+	public static generate(scope: Scope, environment: Environment = Environment.Production): CorsRule[] {
+		const cors = new CORS(scope, environment);
+		return cors.getS3Rules();
+	}
+}

package/test/domain/cors.s3.test.ts

@@ -0,0 +1,92 @@
+import { assert, expect } from "chai";
+import { suite, test } from "mocha-typescript";
+import * as Moq from "typemoq";
+
+import { CORS } from "../../src/domain";
+import { Environment } from "../../src/domain/enums/environment";
+import { Scope } from "../../src/domain/enums/scope";
+
+@suite()
+class CORSS3RulesTest {
+	private testInstanceMock: Moq.IMock<CORS>;
+
+	private get testInstance(): CORS {
+		return this.testInstanceMock.object;
+	}
+
+	public before(): void {
+
+		const cors = new CORS(Scope.Student, Environment.Production);
+		this.testInstanceMock = Moq.Mock.ofInstance(cors);
+		this.testInstanceMock.callBase = true;
+	}
+
+	@test
+	public async getS3Rules_Should_Return_All_Required_Properties(): Promise<void> {
+		// given
+		const expectedProperties = ['allowedOrigins','allowedHeaders','allowedMethods','exposedHeaders','maxAge']
+
+		// when
+		const allDefaultRules = await this.testInstance.getS3Rules();
+
+		//then
+		expectedProperties.forEach((key) => {
+			allDefaultRules.every( rule => expect(rule).to.have.property(key));
+		});
+
+	}
+
+	@test
+	public async getS3Rules_Should_Return_Correct_Default_Domains(): Promise<void> {
+		// given
+		const expectedDomains = ['*.mastersportal.com', '*.bachelorsportal.com', '*.phdportal.com'];
+
+		// when
+		const allDefaultRules = await this.testInstance.getS3Rules();
+
+		// then
+		allDefaultRules.some( rule => expectedDomains.every( domain => rule.allowedOrigins.includes(domain) ) )
+	}
+
+	@test
+	public async getS3Rules_Should_Return_Correct_Allowed_Headers(): Promise<void> {
+		// given
+		const expectedHeaders = ['Authorization'];
+
+		// when
+		const allDefaultRules = await this.testInstance.getS3Rules();
+
+		// then
+		allDefaultRules.some( rule => expectedHeaders.every( header => !rule.allowedHeaders.includes(header) ) )
+	}	
+
+	@test
+	public async getS3Rules_Non_Production_Should_Not_Return_Production_Domains(): Promise<void> {
+		// given
+		const expectedDomains = ['*.mastersportal.fyi', '*.bachelorsportal.fyi', '*.phdportal.fyi'];
+
+		// when
+		const allDefaultRules = await this.testInstance.getS3Rules();
+
+		// then
+		allDefaultRules.some( rule => expectedDomains.every( domain => !rule.allowedOrigins.includes(domain) ) )
+
+	}
+
+	@test
+	public async getS3Rules_Should_Return_Correct_Testing_Domains(): Promise<void> {
+
+		const cors = new CORS(Scope.Student, Environment.Testing);
+		this.testInstanceMock = Moq.Mock.ofInstance(cors);
+		this.testInstanceMock.callBase = true;
+
+		// given
+		const expectedDomains = ['*'];
+
+		// when
+		const allDefaultRules = await this.testInstance.getS3Rules();
+
+		// then
+		allDefaultRules.some( rule => expectedDomains.every( domain => rule.allowedOrigins.includes(domain) ) )
+	}
+}

package/test/domain/cors.valid.domain.test.ts

@@ -0,0 +1,155 @@
+import { assert } from 'chai';
+import { suite, test } from 'mocha-typescript';
+import * as Moq from 'typemoq';
+
+import { CORS } from '../../src/domain';
+import { Environment } from '../../src/domain/enums/environment';
+import { Scope } from '../../src/domain/enums/scope';
+
+@suite()
+class CORSValidDomainTest {
+	private testInstanceMock: Moq.IMock<CORS>;
+
+	private get testInstance(): CORS {
+		return this.testInstanceMock.object;
+	}
+
+	public before(): void {
+
+		const cors = new CORS(Scope.Student, Environment.Production);
+		this.testInstanceMock = Moq.Mock.ofInstance(cors);
+		this.testInstanceMock.callBase = true;
+	}
+
+	@test
+	public async isValidDomain_Should_Return_True_When_DomainIs_Mastersportal(): Promise<void> {
+		// given
+		const providedDomain = 'https://www.mastersportal.com';
+
+		// when
+		const validDomain = await this.testInstance.isValidDomain(providedDomain);
+
+		// then
+		assert.isTrue(validDomain);
+	}
+
+	@test
+	public async isValidDomain_Should_Return_True_When_DomainIs_Mastersportal_With_HTTP(): Promise<void> {
+		// given
+		const providedDomain = 'http://www.mastersportal.com';
+
+		// when
+		const validDomain = await this.testInstance.isValidDomain(providedDomain);
+
+		// then
+		assert.isTrue(validDomain);
+	}
+
+	@test
+	public async isValidDomain_Should_Return_True_When_DomainIs_Bachelorsportal(): Promise<void> {
+		// given
+		const providedDomain = 'https://www.bachelorsportal.com';
+
+		// when
+		const validDomain = await this.testInstance.isValidDomain(providedDomain);
+
+		// then
+		assert.isTrue(validDomain);
+	}
+
+	@test
+	public async isValidDomain_Should_Return_True_When_DomainIs_PhDportal(): Promise<void> {
+		// given
+		const providedDomain = 'https://www.phdportal.com';
+
+		// when
+		const validDomain = await this.testInstance.isValidDomain(providedDomain);
+
+		// then
+		assert.isTrue(validDomain);
+	}
+
+	@test
+	public async isValidDomain_Should_Return_True_When_DomainIs_PhDportalRC(): Promise<void> {
+		// given
+		const providedDomain = 'https://1554112850.rc.phdportal.fyi';
+
+		// when
+		const validDomain = await this.testInstance.isValidDomain(providedDomain);
+
+		// then
+		assert.isTrue(validDomain);
+	}
+
+	@test
+	public async isValidDomain_Should_Return_False_When_DomainIs_BabyShower(): Promise<void> {
+		// given
+		const providedDomain = 'https://www.babyshower.com';
+
+		// when
+		const validDomain = await this.testInstance.isValidDomain(providedDomain);
+
+		// then
+		assert.isFalse(validDomain);
+	}
+
+	@test
+	public async isValidDomain_Should_Return_False_When_DomainIs_Masterportal(): Promise<void> {
+		// given
+		const providedDomain = 'https://www.masterportal.com';
+
+		// when
+		const validDomain = await this.testInstance.isValidDomain(providedDomain);
+
+		// then
+		assert.isFalse(validDomain);
+	}
+
+	@test
+	public async isValidDomain_Should_Return_False_When_DomainIs_Mastersportal_With_SPDY(): Promise<void> {
+		// given
+		const providedDomain = 'spdy://www.mastersportal.com';
+
+		// when
+		const validDomain = await this.testInstance.isValidDomain(providedDomain);
+
+		// then
+		assert.isFalse(validDomain);
+	}
+
+	@test
+	public async isValidDomain_Should_Return_True_When_DomainIs_searchPageMicroFrontend(): Promise<void> {
+		// given
+		const providedDomain = 'https://search-page.prtl.co';
+
+		// when
+		const validDomain = await this.testInstance.isValidDomain(providedDomain);
+
+		// then
+		assert.isTrue(validDomain);
+	}
+
+	@test
+	public async isValidDomain_Should_Return_True_When_DomainIs_AdmissionTestPortalWithoutWWW(): Promise<void> {
+		// given
+		const providedDomain = 'https://admissiontestportal.com';
+
+		// when
+		const validDomain = await this.testInstance.isValidDomain(providedDomain);
+
+		// then
+		assert.isTrue(validDomain);
+	}
+
+	@test
+	public async isValidDomain_Should_Return_True_When_DomainIs_AdmissionTestPortalWithWWW(): Promise<void> {
+		// given
+		const providedDomain = 'https://www.admissiontestportal.com';
+
+		// when
+		const validDomain = await this.testInstance.isValidDomain(providedDomain);
+
+		// then
+		assert.isTrue(validDomain);
+	}
+}

package/test/mocha.opts

@@ -0,0 +1,3 @@
+--require ts-node/register
+--watch-extensions ts
+-c

package/tsconfig.json

@@ -0,0 +1,38 @@
+{
+	"compilerOptions": {
+		"outDir": "bin",
+		"declaration": true,
+		"moduleResolution": "node",
+		"alwaysStrict": true,
+		"strictNullChecks": true,
+		"allowJs": false,
+		"allowUnreachableCode": false,
+		"allowUnusedLabels": false,
+		"noUnusedLocals": false,
+		"noUnusedParameters": false,
+		"noFallthroughCasesInSwitch": true,
+		"noImplicitAny": false,
+		"noImplicitReturns": true,
+		"noImplicitThis": true,
+		"target": "ES6",
+		"module": "commonjs",
+		"experimentalDecorators": true,
+		"esModuleInterop": true,
+		"lib": [
+			"es2017",
+			"dom",
+			"es5",
+			"es6"
+		],
+		"types": [
+			"node"
+		]
+	},
+	"typeRoots": [
+		"node_modules/@types/"
+	],
+	"exclude": [
+		"node_modules",
+		"bin"
+	]
+}

package/tslint.json

@@ -0,0 +1,132 @@
+{
+    "extends": [
+        "tslint:latest"
+    ],
+    "rules": {
+        "ordered-imports": true,
+        "arrow-return-shorthand": true,
+        "callable-types": true,
+        "class-name": true,
+        "comment-format": [
+            true,
+            "check-space"
+        ],
+        "curly": true,
+        "eofline": true,
+        "forin": true,
+        "import-spacing": false,
+        "indent": [
+            true,
+            "tabs"
+        ],
+        "interface-over-type-literal": true,
+        "label-position": true,
+        "max-line-length": [
+            true,
+            200
+        ],
+        "member-access": false,
+        "member-ordering": [
+            true,
+            {
+                "order": [
+                    "static-field",
+                    "instance-field",
+                    "instance-method",
+                    "static-method"
+                ]
+            }
+        ],
+        "no-arg": true,
+        "no-console": [
+            true,
+            "debug",
+            "info",
+            "time",
+            "timeEnd",
+            "trace"
+        ],
+        "no-construct": true,
+        "no-debugger": true,
+        "no-duplicate-super": true,
+        "no-empty": false,
+        "no-empty-interface": true,
+        "no-eval": true,
+        "no-inferrable-types": [
+            true,
+            "ignore-params"
+        ],
+        "no-misused-new": true,
+        "no-non-null-assertion": true,
+        "no-shadowed-variable": true,
+        "no-string-literal": false,
+        "no-string-throw": true,
+        "no-switch-case-fall-through": true,
+        "no-trailing-whitespace": true,
+        "no-unnecessary-initializer": true,
+        "no-unused-expression": true,
+        "no-use-before-declare": true,
+        "no-var-keyword": true,
+        "object-literal-sort-keys": false,
+        "one-line": [
+            true,
+            "check-open-brace",
+            "check-whitespace"
+        ],
+        "prefer-const": false,
+        "radix": true,
+        "quotemark": [
+            true,
+            "single"
+        ],
+        "semicolon": [
+            true,
+            "always"
+        ],
+        "triple-equals": [
+            true,
+            "allow-null-check"
+        ],
+        "typedef": [
+            true,
+            "call-signature",
+            "parameter",
+            "member-variable-declaration",
+            "property-declaration"
+        ],
+        "typedef-whitespace": [
+            true,
+            {
+                "call-signature": "nospace",
+                "index-signature": "nospace",
+                "parameter": "nospace",
+                "property-declaration": "nospace",
+                "variable-declaration": "nospace"
+            }
+        ],
+        "no-implicit-dependencies": [
+            false,
+            [
+                "mocha-typescript",
+                "chai",
+                "typemoq"
+            ]
+        ],
+        "unified-signatures": true,
+        "variable-name": false,
+        "whitespace": [
+            true,
+            "check-branch",
+            "check-decl",
+            "check-operator",
+            "check-separator",
+            "check-type",
+            "check-typecast"
+        ]
+    },
+    "linterOptions": {
+        "exclude": [
+            "node_modules/**"
+        ]
+    }
+}