@thzero/library_server_fastify 0.15.32

package/README.md

@@ -0,0 +1,15 @@
+![GitHub package.json version](https://img.shields.io/github/package-json/v/thzero/library_server_fastify)
+![David](https://img.shields.io/david/thzero/library_server_fastify)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+# library_server_fastify
+
+An opinionated library of common functionality to bootstrap a Fastify based API application.
+
+### Installation
+
+[![NPM](https://nodei.co/npm/@thzero/library_server.png?compact=true)](https://npmjs.org/package/@thzero/library_server_fastify)
+
+### Requirements
+
+#### library_server

package/boot/index.js

@@ -0,0 +1,283 @@
+import path from 'path';
+
+import Fastify from 'fastify';
+import fastifyAuth from 'fastify-auth';
+import fastifyCors from 'fastify-cors';
+import fastifyHelmet from 'fastify-helmet';
+import fastifyStatic from 'fastify-static';
+
+import LibraryConstants from '@thzero/library_server/constants';
+
+import injector from '@thzero/library_common/utility/injector';
+
+import BootMain from '@thzero/library_server/boot';
+
+import pluginApiKey from '@thzero/library_server_fastify/plugins/apiKey';
+import pluginResponseTime from '@thzero/library_server_fastify/plugins/responseTime';
+import pluginSettings from '@thzero/library_server_fastify/plugins/settings';
+import pluginUsageMetrics from '@thzero/library_server_fastify/plugins/usageMetrics';
+
+class FastifyBootMain extends BootMain {
+	async _initApp(args, plugins) {
+		
+		// const serverFactory = (handler, opts) => {
+		// 	const server = http.createServer((req, res) => {
+		// 		handler(req, res)
+		// 	});
+		  
+		// 	return server;
+		// };
+		  
+		// const fastify = Fastify({ serverFactory, logger: true });
+		const fastify = Fastify({ logger: true });
+		const serverHttp = fastify.server;
+
+		// // https://github.com/koajs/cors
+		// app.use(koaCors({
+		// 	allowMethods: 'GET,POST,DELETE',
+		// 	maxAge : 7200,
+		// 	allowHeaders: `${LibraryConstants.Headers.AuthKeys.API}, ${LibraryConstants.Headers.AuthKeys.AUTH}, ${LibraryConstants.Headers.CorrelationId}, Content-Type`,
+		// 	credentials: true,
+		// 	origin: '*'
+		// }));
+		// https://github.com/fastify/fastify-cors
+		fastify.register(fastifyCors, { 
+			allowMethods: 'GET,POST,DELETE',
+			maxAge : 7200,
+			allowHeaders: `${LibraryConstants.Headers.AuthKeys.API}, ${LibraryConstants.Headers.AuthKeys.AUTH}, ${LibraryConstants.Headers.CorrelationId}, Content-Type`,
+			credentials: true,
+			origin: '*'
+		});
+		
+		// // https://www.npmjs.com/package/koa-helmet
+		// app.use(koaHelmet());
+		// https://github.com/fastify/fastify-helmet
+		fastify.register(
+			fastifyHelmet,
+			// Example disables the `contentSecurityPolicy` middleware but keeps the rest.
+			{ 
+				// contentSecurityPolicy: false 
+			}
+		);
+
+		// // error
+		// app.use(async (ctx, next) => {
+		// 	try {
+		// 		await next();
+		// 	}
+		// 	catch (err) {
+		// 		ctx.status = err.status || 500;
+		// 		if (err instanceof TokenExpiredError) {
+		// 			ctx.status = 401;
+		// 			ctx.response.header['WWW-Authenticate'] = 'Bearer error="invalid_token", error_description="The access token expired"'
+		// 		}
+		// 		ctx.app.emit('error', err, ctx);
+		// 		await this.usageMetricsServiceI.register(ctx, err).catch(() => {
+		// 			this.loggerServiceI.exception('KoaBootMain', 'start', err);
+		// 		});
+		// 	}
+		// });
+		fastify.register(async (instance, opts, done) => {
+			// try {
+			// 	done();
+			// }
+			// catch (err) {
+			// 	let status = err.status || 500;
+			// 	if (err instanceof TokenExpiredError) {
+			// 		status = 401;
+			// 		response.header['WWW-Authenticate'] = 'Bearer error="invalid_token", error_description="The access token expired"'
+			// 	}
+			// 	app.emit('error', err, ctx);
+			// 	await this.usageMetricsServiceI.register(ctx, err).catch(() => {
+			// 		this.loggerServiceI.exception('KoaBootMain', 'start', err);
+			// 	});
+			// }
+		});
+
+		// app.on('error', (err, ctx) => {
+		// 	this.loggerServiceI.error('KoaBootMain', 'start', 'Uncaught Exception', err);
+		// });
+
+		// // config
+		// app.use(async (ctx, next) => {
+		// 	ctx.config = this._appConfig;
+		// 	await next();
+		// });
+		// // correlationId
+		// app.use(async (ctx, next) => {
+		// 	ctx.correlationId = ctx.request.header[LibraryConstants.Headers.CorrelationId];
+		// 	await next();
+		// });
+		// fastify.register(async (instance, opts, done) => {
+		// 	instance.addHook('onRequest', (request, reply, next) => {
+		// 		request.config = this._appConfig;
+		// 		request.correlationId = ctx.request.header[LibraryConstants.Headers.CorrelationId];
+		// 		next();
+		// 	});
+
+		// 	done();
+		// });
+		fastify.register(pluginSettings, {
+			config: this._appConfig
+		});
+
+		// // logger
+		// app.use(async (ctx, next) => {
+		// 	await next();
+		// 	const rt = ctx.response.get(ResponseTime);
+		// 	this.loggerServiceI.info2(`${ctx.method} ${ctx.url} - ${rt}`);
+		// });
+
+		// // x-response-time
+		// app.use(async (ctx, next) => {
+		// 	const start = Utility.timerStart();
+		// 	await next();
+		// 	const delta = Utility.timerStop(start, true);
+		// 	ctx.set(ResponseTime, delta);
+		// });
+		// https://github.com/lolo32/fastify-response-time
+		fastify.register(pluginResponseTime, {
+			logger: this.loggerServiceI
+		});
+
+		// app.use(koaStatic('./public'));
+		// https://github.com/fastify/fastify-static
+		const __dirname = path.resolve();
+		fastify.register(fastifyStatic, {
+			root: path.join(__dirname, 'public'),
+			prefix: '/public/', // optional: default '/'
+		});
+
+		this._initPreAuth(fastify);
+
+		// // auth-api-token
+		// app.use(async (ctx, next) => {
+		// 	if (ctx.originalUrl === '/favicon.ico') {
+		// 		await next();
+		// 		return;
+		// 	}
+
+		// 	const key = ctx.get(LibraryConstants.Headers.AuthKeys.API);
+		// 	// this.loggerServiceI.debug('KoaBootMain', 'start', 'auth-api-token.key', key);
+		// 	if (!String.isNullOrEmpty(key)) {
+		// 		const auth = ctx.config.get('auth');
+		// 		if (auth) {
+		// 			const apiKey = auth.apiKey;
+		// 			// this.loggerServiceI.debug('KoaBootMain', 'start', 'auth-api-token.apiKey', apiKey);
+		// 			// this.loggerServiceI.debug('KoaBootMain', 'start', 'auth-api-token.key===apiKey', (key === apiKey));
+		// 			if (key === apiKey) {
+		// 				ctx.state.apiKey = key;
+		// 				await next();
+		// 				return;
+		// 			}
+		// 		}
+		// 	}
+
+		// 	(async () => {
+		// 		await this.usageMetricsServiceI.register(ctx).catch((err) => {
+		// 			this.loggerServiceI.error('KoaBootMain', 'start', 'usageMetrics', err);
+		// 		});
+		// 	})();
+
+		// 	console.log('Unauthorized... auth-api-token failure');
+		// 	ctx.throw(401);
+		// });
+		// fastify.register((instance, opts, done) => {
+		// 	instance.addHook('onRequest', (request, reply, next) => {
+		// 		if (request.originalUrl === '/favicon.ico') {
+		// 			next();
+		// 			return;
+		// 		}
+	
+		// 		const key = request.get(LibraryConstants.Headers.AuthKeys.API);
+		// 		// this.loggerServiceI.debug('KoaBootMain', 'start', 'auth-api-token.key', key);
+		// 		if (!String.isNullOrEmpty(key)) {
+		// 			const auth = request.config.get('auth');
+		// 			if (auth) {
+		// 				const apiKey = auth.apiKey;
+		// 				// this.loggerServiceI.debug('KoaBootMain', 'start', 'auth-api-token.apiKey', apiKey);
+		// 				// this.loggerServiceI.debug('KoaBootMain', 'start', 'auth-api-token.key===apiKey', (key === apiKey));
+		// 				if (key === apiKey) {
+		// 					request.state.apiKey = key;
+		// 					next();
+		// 					return;
+		// 				}
+		// 			}
+		// 		}
+	
+		// 		(async () => {
+		// 			await this.usageMetricsServiceI.register(ctx).catch((err) => {
+		// 				this.loggerServiceI.error('FastifyBootMain', 'start', 'usageMetrics', err);
+		// 			});
+		// 		})();
+	
+		// 		console.log('Unauthorized... auth-api-token failure');
+		// 		request.throw(401);
+		// 		next();
+		// 	});
+
+		// 	done();
+		// });
+		fastify.register(pluginApiKey, {
+			logger: this.loggerServiceI,
+			usageMetrics: this.usageMetricsServiceI
+		});
+
+		fastify.register(fastifyAuth, {
+			logger: this.loggerServiceI,
+			usageMetrics: this.usageMetricsServiceI
+		});
+
+		this._initPostAuth(fastify);
+
+		this._routes = [];
+
+		this._initPreRoutes(fastify);
+
+		for (const pluginRoute of plugins)
+			await pluginRoute.initRoutes(this._routes);
+
+		await this._initRoutes();
+				
+		console.log();
+
+		for (const route of this._routes) {
+			await route.init(injector, fastify, this._appConfig);
+
+			console.log([ route.id ]);
+
+			// for (let i = 0; i < route.router.stack.length; i++)
+			// 	console.log([ route.router.stack[i].path, route.router.stack[i].methods ]);
+
+			console.log();
+		}
+
+		// // usage metrics
+		// app.use(async (ctx, next) => {
+		// 	await next();
+		// 	await this.usageMetricsServiceI.register(ctx).catch((err) => {
+		// 		this.loggerServiceI.error('KoaBootMain', 'start', 'usageMetrics', err);
+		// 	});
+		// });
+		fastify.register(pluginUsageMetrics, {
+			logger: this.loggerServiceI,
+			usageMetrics: this.usageMetricsServiceI
+		});
+
+		return { app: fastify, server: serverHttp, listen: fastify.listen };
+    }
+
+	_initAppListen(app, server, port, err) {
+		app.listen(port, err);
+	}
+
+	async _initAppPost(app, args) {
+		this._initPostRoutes(app);
+	}
+
+	_initRoute(route) {
+		this._routes.push(route);
+	}
+}
+
+export default FastifyBootMain;

package/boot/plugins/admin/news.js

@@ -0,0 +1,11 @@
+import BaseNewsAdminBootPlugin from '@thzero/library_server/boot/plugins/admin/news';
+
+import adminNewsRoute from '../../../routes/admin/news';
+
+class NewsAdminBootPlugin extends BaseNewsAdminBootPlugin {
+	_initRoutesAdminNews() {
+		return new adminNewsRoute();
+	}
+}
+
+export default NewsAdminBootPlugin;

package/boot/plugins/admin/users.js

@@ -0,0 +1,11 @@
+import BaseUsersAdminBootPlugin from '@thzero/library_server/boot/plugins/admin/users';
+
+import adminUsersRoute from '../../../routes/admin/users'
+
+class UsersAdminBootPlugin extends BaseUsersAdminBootPlugin {
+	_initRoutesAdminUsers() {
+		return new adminUsersRoute();
+	}
+}
+
+export default UsersAdminBootPlugin;

package/boot/plugins/api.js

@@ -0,0 +1,16 @@
+import BaseApiBootPlugin from '@thzero/library_server/boot/plugins/api';
+
+import homeRoute from '../../routes/home';
+import versionRoute from '../../routes/version';
+
+class ApiBootPlugin extends BaseApiBootPlugin {
+	_initRoutesHome() {
+		return new homeRoute();
+	}
+
+	_initRoutesVersion() {
+		return new versionRoute();
+	}
+}
+
+export default ApiBootPlugin;

package/boot/plugins/apiFront.js

@@ -0,0 +1,11 @@
+import BaseApiFrontBootPlugin from '@thzero/library_server/boot/plugins/apiFront';
+
+import utilityRoute from '../../routes/utility';
+
+class FrontApiBootPlugin extends BaseApiFrontBootPlugin {
+	_initRoutesUtility() {
+		return new utilityRoute();
+	}
+}
+
+export default FrontApiBootPlugin;

package/boot/plugins/news.js

@@ -0,0 +1,11 @@
+import BaseNewsApiBootPlugin from '@thzero/library_server/boot/plugins/news';
+
+import newsRoute from '../../routes/news';
+
+class NewsApiBootPlugin extends BaseNewsApiBootPlugin {
+	_initRoutesNews() {
+		return new newsRoute();
+	}
+}
+
+export default NewsApiBootPlugin;

package/boot/plugins/users.js

@@ -0,0 +1,11 @@
+import BaseUsersApiBootPlugin from '@thzero/library_server/boot/plugins/users';
+
+import usersRoute from '../../routes/users';
+
+class UsersApiBootPlugin extends BaseUsersApiBootPlugin {
+	_initRoutesUsers() {
+		return new usersRoute();
+	}
+}
+
+export default UsersApiBootPlugin;

package/boot/plugins/usersExtended.js

@@ -0,0 +1,11 @@
+import BaseExtendedUsersApiBootPlugin from '@thzero/library_server/boot/plugins/usersExtended';
+
+import plansService from '../../service/plans';
+
+class ExtendedUsersApiBootPlugin extends BaseExtendedUsersApiBootPlugin {
+	_initServicesPlans() {
+		return new plansService();
+	}
+}
+
+export default ExtendedUsersApiBootPlugin;

package/license.md

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2020-2022 thZero.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@thzero/library_server_fastify",
+  "type": "module",
+  "version": "0.15.32",
+  "version_major": 0,
+  "version_minor": 15,
+  "version_patch": 32,
+  "version_date": "04/18/2022",
+  "description": "An opinionated library of common functionality to bootstrap a Fastify based API application.",
+  "author": "thZero",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thzero/library_server_fastify.git"
+  },
+  "bugs": {
+    "url": "https://github.com/thzero/library_server_fastify/issues"
+  },
+  "homepage": "https://github.com/thzero/library_server_fastify#readme",
+  "engines": {
+    "node": ">=12.8.3"
+  },
+  "scripts": {
+    "cli-update": "./node_modules/.bin/library-cli --updateversion --pi",
+    "cli-update-w": ".\\node_modules\\.bin\\library-cli --updateversion --pi",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "dependencies": {
+    "async-mutex": "^0.3.2",
+    "fastify": "^3.28.0",
+    "fastify-auth": "^1.1.0",
+    "fastify-cors": "^6.0.3",
+    "fastify-helmet": "^7.0.1",
+    "fastify-static": "^4.6.1"
+  },
+  "devDependencies": {
+    "@thzero/library_cli": "^0.15"
+  },
+  "peerDependencies": {
+    "@thzero/library_common": "^0.15",
+    "@thzero/library_common_service": "^0.15"
+  }
+}

package/plugins/apiKey.js

@@ -0,0 +1,49 @@
+import fastifyPlugin from 'fastify-plugin';
+
+import LibraryConstants from '@thzero/library_server/constants';
+
+export default fastifyPlugin((instance, opts, done) => {
+	instance.addHook('onRequest', (request, reply, next) => {
+		if (request.originalUrl === '/favicon.ico') {
+			next();
+			return;
+		}
+
+		const key = request.headers[LibraryConstants.Headers.AuthKeys.API];
+		// opts.logger.debug('KoaBootMain', 'start', 'auth-api-token.key', key);
+		if (!String.isNullOrEmpty(key)) {
+			const auth = request.config.get('auth');
+			if (auth) {
+				const apiKey = auth.apiKey;
+				// this.loggerServiceI.debug('KoaBootMain', 'start', 'auth-api-token.apiKey', apiKey);
+				// this.loggerServiceI.debug('KoaBootMain', 'start', 'auth-api-token.key===apiKey', (key === apiKey));
+				if (key === apiKey) {
+					request.apiKey = key;
+					next();
+					return;
+				}
+			}
+		}
+
+		(async () => {
+			const usageMetrics = {
+				url: request.routerPath,
+				correlationId: request.correlationId,
+				href: request.url,
+				headers: request.headers,
+				host: request.hostname,
+				hostname: request.hostname,
+				querystring: request.query,
+				token: request.token
+			};
+			await opts.usageMetrics.register(usageMetrics).catch((err) => {
+				opts.logger.error('FastifyBootMain', 'start', 'usageMetrics', err);
+			});
+		})();
+
+		console.log('Unauthorized... auth-api-token failure');
+		reply.status(401).send();
+	});
+
+	done();
+});

package/plugins/responseTime.js

@@ -0,0 +1,107 @@
+// https://github.com/lolo32/fastify-response-time
+import fastifyPlugin from 'fastify-plugin';
+
+const symbolRequestTime = Symbol('RequestTimer');
+const symbolServerTiming = Symbol('ServerTiming');
+
+/**
+ *
+ * @param {string} name
+ * @param {number|string} duration
+ * @param {string} description
+ * @return {string}
+ */
+const genTick = (name, duration, description) => {
+	let val = name;
+	// Parse duration. If could not be converted to float, does not add it
+	duration = parseFloat(duration);
+	if (!isNaN(duration)) {
+		val += `;dur=${duration}`;
+	}
+	// Parse the description. If empty, doest not add it. If string with space, double quote value
+	if ('string' === typeof description) {
+		val += `;desc=${description.includes(' ') ? `'${description}'` : description}`;
+	}
+
+	return val;
+};
+
+/**
+ * Decorators
+ *
+ * @param {fastify} instance
+ * @param {function} instance.decorateReply
+ * @param {Object} opts
+ * @param {function} next
+ */
+export default fastifyPlugin((instance, opts, done) => {
+	// Check the options, and corrects with the default values if inadequate
+	if (isNaN(opts.digits) || 0 > opts.digits) {
+		opts.digits = 2;
+	}
+	opts.header = opts.header || 'X-Response-Time';
+
+	// Hook to be triggered on request (start time)
+	instance.addHook('onRequest', (request, reply, next) => {
+		// Store the start timer in nanoseconds resolution
+		// istanbul ignore next
+		if (request.raw && reply.raw) {
+			// support fastify >= v2
+			request.raw[symbolRequestTime] = process.hrtime();
+			reply.raw[symbolServerTiming] = {};
+		} 
+		else if (request.req && reply.res) {
+			// support fastify >= v2
+			request.req[symbolRequestTime] = process.hrtime();
+			reply.res[symbolServerTiming] = {};
+		} 
+		else {
+			request[symbolRequestTime] = process.hrtime();
+			reply[symbolServerTiming] = {};
+		}
+
+		next();
+	});
+
+	// Hook to be triggered just before response to be send
+	instance.addHook('onSend', (request, reply, payload, next) => {
+		// check if Server-Timing need to be added
+		const serverTiming = (reply.raw ? reply.raw[symbolServerTiming] : reply.res[symbolServerTiming]);
+		const headers = [];
+		for (const name of Object.keys(serverTiming)) {
+			headers.push(serverTiming[name]);
+		}
+		if (headers.length) {
+			reply.header('Server-Timing', headers.join(','));
+		}
+
+		// Calculate the duration, in nanoseconds …
+		const hrDuration = (request.raw ? request.raw[symbolRequestTime] : request.req[symbolRequestTime]);
+		// … convert it to milliseconds …
+		const duration = (hrDuration[0] * 1e3 + hrDuration[1] / 1e6).toFixed(opts.digits);
+		// … add the header to the response
+		reply.header(opts.header, duration);
+
+		opts.logger.info2(`${request.method} ${request.url} - ${duration}`);
+
+		next();
+	});
+
+	// Can be used to add custom timing information
+	instance.decorateReply('setServerTiming', function (name, duration, description) {
+		// Reference to the res object storing values …
+		const serverTiming = this.res[symbolServerTiming];
+		// … return if value already exists (all subsequent occurrences MUST be ignored without signaling an error) …
+		if (serverTiming.hasOwnProperty(name)) {
+			return false;
+		}
+		// … add the value the the list to send later
+		serverTiming[name] = genTick(name, duration, description);
+		// … return true, the value was added to the list
+		return true;
+	});
+
+	done();
+});
+// Not before 0.31 (onSend hook added to this version)
+// }, '>= 0.31');

package/plugins/settings.js

@@ -0,0 +1,13 @@
+import fastifyPlugin from 'fastify-plugin';
+
+import LibraryConstants from '@thzero/library_server/constants';
+
+export default fastifyPlugin((instance, opts, done) => {
+	instance.addHook('onRequest', (request, reply, next) => {
+		request.config = opts.config;
+		request.correlationId = request.headers[LibraryConstants.Headers.CorrelationId];
+		next();
+	});
+
+	done();
+});

package/plugins/usageMetrics.js

@@ -0,0 +1,25 @@
+import fastifyPlugin from 'fastify-plugin';
+
+export default fastifyPlugin((instance, opts, done) => {
+	instance.addHook('onSend', (request, reply, payload, next) => {
+		(async () => {
+			const usageMetrics = {
+				url: request.routerPath,
+				correlationId: request.correlationId,
+				href: request.url,
+				headers: request.headers,
+				host: request.hostname,
+				hostname: request.hostname,
+				querystring: request.query,
+				token: request.token
+			};
+			await opts.usageMetrics.register(usageMetrics).catch((err) => {
+				opts.logger.error('usageMetrics', 'start', 'usageMetrics', err);
+			});
+		})();
+
+		next();
+	});
+
+	done();
+});

package/routes/admin/index.js

@@ -0,0 +1,123 @@
+import koaBody from 'koa-body';
+
+import Utility from '@thzero/library_common/utility';
+
+import BaseRoute from '../index';
+
+import authentication from '../../middleware/authentication';
+import authorization from '../../middleware/authorization';
+
+class AdminBaseRoute extends BaseRoute {
+	constructor(urlFragment, role, serviceKey) {
+		if (!urlFragment)
+			throw Error('Invalid url fragment');
+
+		super(`/admin/${urlFragment}`);
+
+		this._options = {
+			role: role,
+			serviceKey: serviceKey
+		}
+
+		// this._service = null;
+	}
+
+	async init(injector, config) {
+		const router = await super.init(injector, config);
+		router.service = injector.getService(this._options.serviceKey);
+		// this._service = injector.getService(this._options.serviceKey);
+	}
+
+	_allowsCreate() {
+		return true;
+	}
+
+	_allowsDelete() {
+		return true;
+	}
+
+	_allowsUpdate() {
+		return true;
+	}
+
+	_initializeRoutesCreate(router) {
+		const self = this;
+		router.post('/',
+			authentication(true),
+			authorization([ `${self._options.role}.create` ]),
+			koaBody({
+				text: false,
+			}),
+			// eslint-disable-next-line
+			async (ctx, next) => {
+				// const service = this._injector.getService(this._options.serviceKey);
+				// const response = (await router.service.create(ctx.correlationId, ctx.state.user, ctx.request.body)).check(ctx);
+				const response = (await ctx.router.service.create(ctx.correlationId, ctx.state.user, ctx.request.body)).check(ctx);
+				this._jsonResponse(ctx, Utility.stringify(response));
+			}
+		);
+	}
+
+	_initializeRoutesDelete(router) {
+		const self = this;
+		router.delete('/:id',
+			authentication(true),
+			authorization([ `${self._options.role}.delete` ]),
+			// eslint-disable-next-line
+			async (ctx, next) => {
+				// const service = this._injector.getService(this._options.serviceKey);
+				// const response = (await service.delete(ctx.correlationId, ctx.state.user, ctx.params.id)).check(ctx);
+				const response = (await ctx.router.service.delete(ctx.correlationId, ctx.state.user, ctx.params.id)).check(ctx);
+				this._jsonResponse(ctx, Utility.stringify(response));
+			}
+		);
+	}
+
+	_initializeRoutesUpdate(router) {
+		const self = this;
+		router.post('/:id',
+			authentication(true),
+			authorization([ `${self._options.role}.update` ]),
+			koaBody({
+				text: false,
+			}),
+			// eslint-disable-next-line
+			async (ctx, next) => {
+				// const service = this._injector.getService(this._options.serviceKey);
+				// const response = (await service.update(ctx.correlationId, ctx.state.user, ctx.params.id, ctx.request.body)).check(ctx);
+				const response = (await ctx.router.service.update(ctx.correlationId, ctx.state.user, ctx.params.id, ctx.request.body)).check(ctx);
+				this._jsonResponse(ctx, Utility.stringify(response));
+			}
+		);
+	}
+
+	_initializeRoutes(router) {
+		if (this._allowsDelete)
+			this._initializeRoutesDelete(router);
+
+		router.post('/search',
+			authentication(true),
+			authorization([ `${this._options.role}.search` ]),
+			koaBody({
+				text: false,
+			}),
+			// eslint-disable-next-line
+			async (ctx, next) => {
+				// const service = this._injector.getService(this._options.serviceKey);
+				// const response = (await service.search(ctx.correlationId, ctx.state.user, ctx.request.body)).check(ctx);
+				const response = (await ctx.router.service.search(ctx.correlationId, ctx.state.user, ctx.request.body)).check(ctx);
+				this._jsonResponse(ctx, Utility.stringify(response));
+			}
+		);
+
+		if (this._allowsUpdate())
+			this._initializeRoutesUpdate(router);
+
+		if (this._allowsCreate())
+			this._initializeRoutesCreate(router);
+
+		return router;
+	}
+}
+
+export default AdminBaseRoute;

package/routes/admin/news.js

@@ -0,0 +1,22 @@
+import LibraryConstants from '../../constants';
+
+import AdminRoute from './index'
+
+class NewsAdminRoute extends AdminRoute {
+	constructor(urlFragment, role, serviceKey) {
+		urlFragment = urlFragment ? urlFragment : 'news';
+		role = role ? role : 'news';
+		serviceKey = serviceKey ? serviceKey : LibraryConstants.InjectorKeys.SERVICE_ADMIN_NEWS;
+		super(urlFragment, role, serviceKey);
+	}
+
+	get id() {
+		return 'admin-news';
+	}
+
+	get _version() {
+		return 'v1';
+	}
+}
+
+export default NewsAdminRoute;

package/routes/admin/users.js

@@ -0,0 +1,26 @@
+import LibraryConstants from '../../constants';
+
+import AdminRoute from './index'
+
+class UsersAdminRoute extends AdminRoute {
+	constructor(urlFragment, role, serviceKey) {
+		urlFragment = urlFragment ? urlFragment : 'users';
+		role = role ? role : 'users';
+		serviceKey = serviceKey ? serviceKey : LibraryConstants.InjectorKeys.SERVICE_ADMIN_USERS;
+		super(urlFragment, role, serviceKey);
+	}
+
+	get id() {
+		return 'admin-users';
+	}
+
+	_allowsCreate() {
+		return false;
+	}
+
+	get _version() {
+		return 'v1';
+	}
+}
+
+export default UsersAdminRoute;

package/routes/baseNews.js

@@ -0,0 +1,38 @@
+import LibraryConstants from '../constants';
+
+import Utility from '@thzero/library_common/utility';
+
+import BaseRoute from './index';
+
+import authentication from '../middleware/authentication';
+
+class BaseNewsRoute extends BaseRoute {
+	constructor(prefix, version) {
+		super(prefix ? prefix : '/news');
+
+		// this._serviceNews = null;
+	}
+
+	async init(injector, app, config) {
+		await super.init(injector, app, config);
+		// this._serviceNews = injector.getService(LibraryConstants.InjectorKeys.SERVICE_NEWS);
+		this._inject(app, injector, LibraryConstants.InjectorKeys.SERVICE_NEWS, LibraryConstants.InjectorKeys.SERVICE_NEWS);
+	}
+
+	get id() {
+		return 'news';
+	}
+
+	_initializeRoutes(router) {
+		// authentication(false),
+		router.get(this._join('/latest/:date'), 
+			async (request, reply) => {
+				// const service = this._injector.getService(LibraryConstants.InjectorKeys.SERVICE_NEWS);
+				// const response = (await service.latest(ctx.correlationId, ctx.state.user, parseInt(ctx.params.date))).check(ctx);
+				const response = (await request.serviceNews.latest(request.correlationId, request.user, parseInt(request.params.date))).check(request);
+				this._jsonResponse(reply, Utility.stringify(response));
+			});
+	}
+}
+
+export default BaseNewsRoute;

package/routes/baseUsers.js

@@ -0,0 +1,103 @@
+import koaBody from 'koa-body';
+
+import LibraryConstants from '../constants';
+
+import Utility from '@thzero/library_common/utility';
+
+import BaseRoute from './index';
+
+import authentication from '../middleware/authentication';
+import authorization from '../middleware/authorization';
+
+class BaseUsersRoute extends BaseRoute {
+	constructor(prefix, version) {
+		super(prefix ? prefix : '/users');
+
+		// this._serviceUsers = null;
+	}
+
+	async init(injector, app, config) {
+		await super.init(injector, app, config);
+		// this._serviceUsers = injector.getService(LibraryConstants.InjectorKeys.SERVICE_USERS);
+		this._inject(app, injector, LibraryConstants.InjectorKeys.SERVICE_USERS, LibraryConstants.InjectorKeys.SERVICE_USERS);
+	}
+
+	get id() {
+		return 'users';
+	}
+
+	_initializeRoutes(router) {
+		this._initializeRoutesGamerById(router);
+		this._initializeRoutesGamerByTag(router);
+		this._initializeRoutesRefreshSettings(router);
+		this._initializeRoutesUpdate(router);
+		this._initializeRoutesUpdateSettings(router);
+	}
+
+	_initializeRoutesGamerById(router) {
+		return router.get('/gamerId/:gamerId',
+			// authentication(false),
+			// // authorization('user'),
+			// eslint-disable-next-line
+			async (request, reply) => {
+				// const service = this._injector.getService(LibraryConstants.InjectorKeys.SERVICE_USERS);
+				const response = (await router[LibraryConstants.InjectorKeys.SERVICE_USERS].fetchByGamerId(request.correlationId, request.params.gamerId)).check(request);
+				this._jsonResponse(reply, Utility.stringify(response));
+			}
+		);
+	}
+
+	_initializeRoutesGamerByTag(router) {
+		return router.get('/gamerTag/:gamerTag',
+			// authentication(false),
+			// // authorization('user'),
+			// eslint-disable-next-line
+			async (request, reply) => {
+				// const service = this._injector.getService(LibraryConstants.InjectorKeys.SERVICE_USERS);
+				const response = (await router[LibraryConstants.InjectorKeys.SERVICE_USERS].fetchByGamerTag(request.correlationId, request.params.gamerTag)).check(request);
+				this._jsonResponse(reply, Utility.stringify(response));
+			}
+		);
+	}
+
+	_initializeRoutesRefreshSettings(router) {
+		return router.post('/refresh/settings',
+			// authentication(true),
+			// authorization('user'),
+			// eslint-disable-next-line
+			async (request, reply) => {
+				// const service = this._injector.getService(LibraryConstants.InjectorKeys.SERVICE_USERS);
+				const response = (await router[LibraryConstants.InjectorKeys.SERVICE_USERS].refreshSettings(request.correlationId, request.body)).check(request);
+				this._jsonResponse(reply, Utility.stringify(response));
+			}
+		);
+	}
+
+	_initializeRoutesUpdate(router) {
+		return router.post('/update',
+			// authentication(true),
+			// authorization('user'),
+			// eslint-disable-next-line
+			async (request, reply) => {
+				// const service = this._injector.getService(LibraryConstants.InjectorKeys.SERVICE_USERS);
+				const response = (await router[LibraryConstants.InjectorKeys.SERVICE_USERS].update(request.correlationId, request.body)).check(request);
+				this._jsonResponse(reply, Utility.stringify(response));
+			}
+		);
+	}
+
+	_initializeRoutesUpdateSettings(router) {
+		return router.post('/update/settings',
+			// authentication(true),
+			// authorization('user'),
+			// eslint-disable-next-line
+			async (request, reply) => {
+				// const service = this._injector.getService(LibraryConstants.InjectorKeys.SERVICE_USERS);
+				const response = (await router[LibraryConstants.InjectorKeys.SERVICE_USERS].updateSettings(request.correlationId, request.body)).check(request);
+				this._jsonResponse(reply, Utility.stringify(response));
+			}
+		);
+	}
+}
+
+export default BaseUsersRoute;

package/routes/home.js

@@ -0,0 +1,28 @@
+import BaseRoute from './index';
+
+class HomeRoute extends BaseRoute {
+	constructor(prefix) {
+		super(prefix ? prefix : '');
+	}
+
+	get id() {
+		return 'home';
+	}
+
+	_initializeRoutes(router) {
+		// eslint-disable-next-linethis._prefix
+		router.get(this._join('/'), (request, reply) => {
+			reply.status(401).send();
+		});
+	}
+
+	get _ignoreApi() {
+		return true;
+	}
+
+	get _version() {
+		return '';
+	}
+}
+
+export default HomeRoute;

package/routes/index.js

@@ -0,0 +1,39 @@
+import fastifyPlugin from 'fastify-plugin';
+
+import BaseRoute from'@thzero/library_server/routes/index';
+
+class FastifyBaseRoute extends BaseRoute {
+	_initializeRouter(app, config) {
+		return app;
+	}
+
+	async _inject(app, injector, key, name) {
+		const service = injector.getService(key);
+		if (!service)
+			throw Error(`Invalid service for '${key}'.`);
+
+		app.register(fastifyPlugin((instance, opts, done) => {
+			instance.decorate(opts.name, opts.service);
+			done();
+		}), {
+			name: name,
+			service: service
+		});
+	}
+
+	_join(path) {
+		return this._prefix + path; 
+	}
+
+	_jsonResponse(reply, json) {
+		if (!reply)
+			throw Error('Invalid context for response.');
+			
+		reply
+			.code(200)
+			.header('Content-Type', 'application/json; charset=utf-8')
+			.send(json);
+	}
+}
+
+export default FastifyBaseRoute;

package/routes/news.js

@@ -0,0 +1,6 @@
+import BaseNewsRoute from './baseNews';
+
+class NewsRoute extends BaseNewsRoute {
+}
+
+export default NewsRoute;

package/routes/plans.js

@@ -0,0 +1,40 @@
+import LibraryConstants from '../constants';
+
+import Utility from '@thzero/library_common/utility';
+
+import BaseRoute from './index';
+
+class PlansRoute extends BaseRoute {
+	constructor(prefix) {
+		super(prefix ? prefix : '/plans');
+
+		// this._servicePlans = null;
+	}
+
+	async init(injector, app, config) {
+		await super.init(injector, app, config);
+		// this._servicePlans = injector.getService(LibraryConstants.InjectorKeys.SERVICE_PLANS);
+		this._inject(app, injector, LibraryConstants.InjectorKeys.SERVICE_PLANS, LibraryConstants.InjectorKeys.SERVICE_PLANS);
+	}
+
+	get id() {
+		return 'plans';
+	}
+
+	_initializeRoutes(router) {
+		router.get(this._join('/'),
+			// eslint-disable-next-line
+			async (ctx, next) => {
+				// const service = this._injector.getService(LibraryConstants.InjectorKeys.SERVICE_PLANS);
+				const response = (await router[LibraryConstants.InjectorKeys.SERVICE_PLANS].logger(request.correlationI)).check(request);
+				this._jsonResponse(reply, Utility.stringify(response));
+			}
+		);
+	}
+
+	get _version() {
+		return 'v1';
+	}
+}
+
+export default PlansRoute;

package/routes/users.js

@@ -0,0 +1,6 @@
+import BaseUsersRoute from './baseUsers';
+
+class UsersRoute extends BaseUsersRoute {
+}
+
+export default UsersRoute;

package/routes/utility.js

@@ -0,0 +1,51 @@
+import koaBody from 'koa-body';
+
+import LibraryConstants from '../constants';
+
+import Utility from '@thzero/library_common/utility';
+
+import BaseRoute from './index';
+
+import authentication from '../middleware/authentication';
+// import authorization from '../middleware/authorization';
+
+class UtilityRoute extends BaseRoute {
+	constructor(prefix) {
+		super(prefix ? prefix : '/utility');
+
+		// this._serviceUtility = null;
+	}
+
+	async init(injector, app, config) {
+		await super.init(injector, app, config);
+		// this._serviceUtility = injector.getService(LibraryConstants.InjectorKeys.SERVICE_UTILITY);
+		this._inject(app, injector, LibraryConstants.InjectorKeys.SERVICE_UTILITY, LibraryConstants.InjectorKeys.SERVICE_UTILITY);
+	}
+
+	get id() {
+		return 'utility';
+	}
+
+	_initializeRoutes(router) {
+		router.post('/logger',
+			authentication(false),
+			// authorization('utility'),
+			// eslint-disable-next-line,
+			koaBody({
+				text: false,
+			}),
+			async (ctx, next) => {
+				// const service = this._injector.getService(LibraryConstants.InjectorKeys.SERVICE_UTILITY);
+				// const response = (await service.logger(ctx.correlationId, ctx.request.body)).check(ctx);
+				const response = (await router[LibraryConstants.InjectorKeys.SERVICE_UTILITY].logger(request.correlationI, request.body)).check(request);
+				this._jsonResponse(reply, Utility.stringify(response));
+			}
+		);
+	}
+
+	get _version() {
+		return 'v1';
+	}
+}
+
+export default UtilityRoute;

package/routes/version.js

@@ -0,0 +1,40 @@
+import LibraryConstants from '@thzero/library_server/constants';
+
+import Utility from '@thzero/library_common/utility';
+
+import BaseRoute from './index';
+
+class VersionRoute extends BaseRoute {
+	constructor(prefix) {
+		super(prefix ? prefix : '');
+
+		// this._serviceVersion = null;
+	}
+
+	async init(injector, app, config) {
+		await super.init(injector, app, config);
+		// this._serviceVersion = injector.getService(LibraryConstants.InjectorKeys.SERVICE_VERSION);
+		this._inject(app, injector, LibraryConstants.InjectorKeys.SERVICE_VERSION, LibraryConstants.InjectorKeys.SERVICE_VERSION);
+	}
+
+	get id() {
+		return 'version';
+	}
+
+	_initializeRoutes(router) {
+		router.get(this._join('/version'), 
+			// eslint-disable-next-line
+			async (request, reply) => {
+				// const service = this._injector.getService(LibraryConstants.InjectorKeys.SERVICE_VERSION);
+				const response = (await router[LibraryConstants.InjectorKeys.SERVICE_VERSION].version(request.correlationId)).check(request);
+				this._jsonResponse(reply, Utility.stringify(response));
+			}
+		);
+	}
+
+	get _version() {
+		return 'v1';
+	}
+}
+
+export default VersionRoute;