@thzero/library_server 0.17.3 → 0.17.4

package/service/utility.js

@@ -1,177 +1,177 @@
-import fs from 'fs';
-import path from 'path';
-import { Mutex as asyncMutex } from 'async-mutex';
-
-import LibraryServerConstants from '@thzero/library_server/constants.js';
-
-import LibraryCommonUtility from '@thzero/library_common/utility/index.js';
-
-import Service from './index.js';
-
-class UtilityService extends Service {
-	constructor() {
-		super();
-
-		this._servicePlans = null;
-		this._serviceVersion = null;
-
-		this._openSourceResponse = null;
-
-		this._initializeResponse = null;
-		this._mutexInitialize = new asyncMutex();
-		this._ttlInitialize = null;
-		this._ttlInitializeDiff = 1000 * 30;
-	}
-
-	async init(injector) {
-		await super.init(injector);
-
-		this._servicePlans = this._injector.getService(LibraryServerConstants.InjectorKeys.SERVICE_PLANS);
-		this._serviceVersion = this._injector.getService(LibraryServerConstants.InjectorKeys.SERVICE_VERSION);
-
-		await this._initializeOopenSource();
-	}
-
-	async initialize(correlationId) {
-		const now = LibraryCommonUtility.getTimestamp();
-		const ttlInitialize = this._ttlInitialize ? this._ttlInitialize : 0;
-		const delta = now - ttlInitialize;
-		if (this._initializeResponse && (delta <= this._ttlInitializeDiff))
-			return this._initializeResponse;
-
-		const release = await this._mutexInitialize.acquire();
-		try {
-			if (this._initializeResponse)
-				return this._initializeResponse;
-
-			const response = this._initResponse(correlationId);
-			response.results = {};
-
-			const responsePlans = await this._servicePlans.listing(correlationId);
-			if (this._hasFailed(responsePlans))
-				return responsePlans;
-
-			response.results.plans = responsePlans.results;
-
-			const responseVersion = await this._serviceVersion.version(correlationId);
-			if (this._hasFailed(responseVersion))
-				return responseVersion;
-
-			response.results.version = responseVersion.results;
-
-			await this._intialize(correlationId, response);
-
-			this._ttlInitialize = LibraryCommonUtility.getTimestamp();
-			this._initializeResponse = response;
-			return response;
-		}
-		finally {
-			release();
-		}
-	}
-
-	async logger(content, correlationId) {
-		if (!content)
-			return this._error('UtilityService', 'logger');
-
-		const type = content.type;
-		switch(type) {
-			case 'DEBUG':
-				this._logger.debug('UtilityService', 'logger', content.message, content.data, correlationId, true);
-				break;
-			case 'ERROR':
-				this._logger.error('UtilityService', 'logger', content.message, content.data, correlationId, true);
-				break;
-			case 'EXCEPTION':
-				this._logger.exception('UtilityService', 'logger', content.ex, correlationId, true);
-				break;
-			case 'FATAL':
-				this._logger.fatal('UtilityService', 'logger', content.message, content.data, correlationId, true);
-				break;
-			case 'INFO':
-				this._logger.info('UtilityService', 'logger', content.message, content.data, correlationId, true);
-				break;
-			case 'TRACE':
-				this._logger.trace('UtilityService', 'logger', content.message, content.data, correlationId, true);
-				break;
-			case 'WARN':
-				this._logger.warn('UtilityService', 'logger', content.message, content.data, correlationId, true);
-				break;
-		}
-
-		return this._success(correlationId);
-	}
-	
-	async openSource(correlationId) {
-		return this._openSourceResponse ? this._openSourceResponse : this._error();
-	}
-
-	_intialize(correlationId, response) {
-	}
-
-	async _initializeOopenSource(correlationId) {
-		this._openSourceResponse = this._initResponse(correlationId);
-		this._openSourceResponse.results = [];
-
-		try {
-			const __dirname = path.resolve();
-			const dir = path.join(path.resolve(__dirname), 'node_modules', '@thzero');
-			const dirs = await fs.promises.readdir(dir);
-	
-			console.log(`\tOpenSource...`);
-			
-			let file;
-			let importPath;
-			let fileI;
-			let items;
-			for (const item of dirs) {
-				try {
-					file = path.join(dir, item, 'openSource.js');
-					console.log(`\t${file}...`);
-					if (!fs.existsSync(file)){
-						console.log(`\t...not found.`);
-						continue;
-					}
-						
-					importPath = ['@thzero', item, 'openSource.js'].join('/');
-					console.log(`\t${importPath}...`);
-					fileI = await import(importPath);
-					if (!fileI.default) {
-						console.log(`\t...failed to load.`);
-						continue;
-					}
-
-					items = fileI.default();
-					items.forEach(element => {
-						if (element.category !== 'server')
-							return;
-						if (this._openSourceResponse.results.filter(l => l.name === element.name).length > 0)
-							return;
-						this._openSourceResponse.results.push(element);
-					});
-					console.log(`\t...processed.`);
-				}
-				catch(err) {
-					console.log(`\t...failed.`, err);
-					this._logger.warn('UtilityService', '_initializeOopenSource', null, err, correlationId);
-				}
-			}
-		}
-		catch(err) {
-			this._logger.warn('UtilityService', '_initializeOopenSource', null, err, correlationId);
-		}
-		finally {
-			console.log(`\t...OpenSource`);
-		}
-
-		// response.results = await this._openSourceServer(correlationId);
-		this._openSource(correlationId, this._openSourceResponse.results);
-
-		this._openSourceResponse.results = this._openSourceResponse.results.sort((a, b) => a.name.localeCompare(b.name));
-	}
-
-	_openSource(correlationId, openSource) {
-	}
-}
-
-export default UtilityService;
+import fs from 'fs';
+import path from 'path';
+import { Mutex as asyncMutex } from 'async-mutex';
+
+import LibraryServerConstants from '@thzero/library_server/constants.js';
+
+import LibraryCommonUtility from '@thzero/library_common/utility/index.js';
+
+import Service from './index.js';
+
+class UtilityService extends Service {
+	constructor() {
+		super();
+
+		this._servicePlans = null;
+		this._serviceVersion = null;
+
+		this._openSourceResponse = null;
+
+		this._initializeResponse = null;
+		this._mutexInitialize = new asyncMutex();
+		this._ttlInitialize = null;
+		this._ttlInitializeDiff = 1000 * 30;
+	}
+
+	async init(injector) {
+		await super.init(injector);
+
+		this._servicePlans = this._injector.getService(LibraryServerConstants.InjectorKeys.SERVICE_PLANS);
+		this._serviceVersion = this._injector.getService(LibraryServerConstants.InjectorKeys.SERVICE_VERSION);
+
+		await this._initializeOopenSource();
+	}
+
+	async initialize(correlationId) {
+		const now = LibraryCommonUtility.getTimestamp();
+		const ttlInitialize = this._ttlInitialize ? this._ttlInitialize : 0;
+		const delta = now - ttlInitialize;
+		if (this._initializeResponse && (delta <= this._ttlInitializeDiff))
+			return this._initializeResponse;
+
+		const release = await this._mutexInitialize.acquire();
+		try {
+			if (this._initializeResponse)
+				return this._initializeResponse;
+
+			const response = this._initResponse(correlationId);
+			response.results = {};
+
+			const responsePlans = await this._servicePlans.listing(correlationId);
+			if (this._hasFailed(responsePlans))
+				return responsePlans;
+
+			response.results.plans = responsePlans.results;
+
+			const responseVersion = await this._serviceVersion.version(correlationId);
+			if (this._hasFailed(responseVersion))
+				return responseVersion;
+
+			response.results.version = responseVersion.results;
+
+			await this._intialize(correlationId, response);
+
+			this._ttlInitialize = LibraryCommonUtility.getTimestamp();
+			this._initializeResponse = response;
+			return response;
+		}
+		finally {
+			release();
+		}
+	}
+
+	async logger(content, correlationId) {
+		if (!content)
+			return this._error('UtilityService', 'logger');
+
+		const type = content.type;
+		switch(type) {
+			case 'DEBUG':
+				this._logger.debug('UtilityService', 'logger', content.message, content.data, correlationId, true);
+				break;
+			case 'ERROR':
+				this._logger.error('UtilityService', 'logger', content.message, content.data, correlationId, true);
+				break;
+			case 'EXCEPTION':
+				this._logger.exception('UtilityService', 'logger', content.ex, correlationId, true);
+				break;
+			case 'FATAL':
+				this._logger.fatal('UtilityService', 'logger', content.message, content.data, correlationId, true);
+				break;
+			case 'INFO':
+				this._logger.info('UtilityService', 'logger', content.message, content.data, correlationId, true);
+				break;
+			case 'TRACE':
+				this._logger.trace('UtilityService', 'logger', content.message, content.data, correlationId, true);
+				break;
+			case 'WARN':
+				this._logger.warn('UtilityService', 'logger', content.message, content.data, correlationId, true);
+				break;
+		}
+
+		return this._success(correlationId);
+	}
+	
+	async openSource(correlationId) {
+		return this._openSourceResponse ? this._openSourceResponse : this._error();
+	}
+
+	_intialize(correlationId, response) {
+	}
+
+	async _initializeOopenSource(correlationId) {
+		this._openSourceResponse = this._initResponse(correlationId);
+		this._openSourceResponse.results = [];
+
+		try {
+			const __dirname = path.resolve();
+			const dir = path.join(path.resolve(__dirname), 'node_modules', '@thzero');
+			const dirs = await fs.promises.readdir(dir);
+	
+			console.log(`\tOpenSource...`);
+			
+			let file;
+			let importPath;
+			let fileI;
+			let items;
+			for (const item of dirs) {
+				try {
+					file = path.join(dir, item, 'openSource.js');
+					console.log(`\t${file}...`);
+					if (!fs.existsSync(file)){
+						console.log(`\t...not found.`);
+						continue;
+					}
+						
+					importPath = ['@thzero', item, 'openSource.js'].join('/');
+					console.log(`\t${importPath}...`);
+					fileI = await import(importPath);
+					if (!fileI.default) {
+						console.log(`\t...failed to load.`);
+						continue;
+					}
+
+					items = fileI.default();
+					items.forEach(element => {
+						if (element.category !== 'server')
+							return;
+						if (this._openSourceResponse.results.filter(l => l.name === element.name).length > 0)
+							return;
+						this._openSourceResponse.results.push(element);
+					});
+					console.log(`\t...processed.`);
+				}
+				catch(err) {
+					console.log(`\t...failed.`, err);
+					this._logger.warn('UtilityService', '_initializeOopenSource', null, err, correlationId);
+				}
+			}
+		}
+		catch(err) {
+			this._logger.warn('UtilityService', '_initializeOopenSource', null, err, correlationId);
+		}
+		finally {
+			console.log(`\t...OpenSource`);
+		}
+
+		// response.results = await this._openSourceServer(correlationId);
+		this._openSource(correlationId, this._openSourceResponse.results);
+
+		this._openSourceResponse.results = this._openSourceResponse.results.sort((a, b) => a.name.localeCompare(b.name));
+	}
+
+	_openSource(correlationId, openSource) {
+	}
+}
+
+export default UtilityService;

package/service/version.js

@@ -1,32 +1,32 @@
-import fs from 'fs';
-import path from 'path';
-
-import Service from './index.js';
-
-class VersionService extends Service {
-	async version(correlationId) {
-		const filePath = path.join(process.cwd(), 'package.json');
-		const file = fs.readFileSync(filePath, 'utf8');
-		if (String.isNullOrEmpty(file))
-			throw Error('Invalid package.json file for versioning; expected in the <app root> folder.');
-
-		const packageObj = JSON.parse(file);
-		if (!packageObj)
-			throw Error('Invalid package.json file for versioning.');
-
-		return this._generate(correlationId, packageObj.version_major, packageObj.version_minor, packageObj.version_patch, packageObj.version_date);
-	}
-
-	_generate(correlationId, version_major, version_minor, version_patch, version_date) {
-		const response = this._success(correlationId);
-		response.results = {
-			major: version_major,
-			minor: version_minor,
-			patch: version_patch,
-			date: version_date
-		};
-		return response;
-	}
-}
-
-export default VersionService;
+import fs from 'fs';
+import path from 'path';
+
+import Service from './index.js';
+
+class VersionService extends Service {
+	async version(correlationId) {
+		const filePath = path.join(process.cwd(), 'package.json');
+		const file = fs.readFileSync(filePath, 'utf8');
+		if (String.isNullOrEmpty(file))
+			throw Error('Invalid package.json file for versioning; expected in the <app root> folder.');
+
+		const packageObj = JSON.parse(file);
+		if (!packageObj)
+			throw Error('Invalid package.json file for versioning.');
+
+		return this._generate(correlationId, packageObj.version_major, packageObj.version_minor, packageObj.version_patch, packageObj.version_date);
+	}
+
+	_generate(correlationId, version_major, version_minor, version_patch, version_date) {
+		const response = this._success(correlationId);
+		response.results = {
+			major: version_major,
+			minor: version_minor,
+			patch: version_patch,
+			date: version_date
+		};
+		return response;
+	}
+}
+
+export default VersionService;

package/utility/injector.js

@@ -1,59 +1,59 @@
-class Injector {
-	constructor() {
-		this._di = {};
-	}
-
-	addService(key, dependency) {
-		if (String.isNullOrEmpty(key))
-			throw Error(`Invalid injector key '${key}'.`);
-		if (!dependency)
-			throw Error('Invalid injector dependency.');
-
-		if (this._di[key])
-			return;
-
-		this._di[key] = { dependency: dependency };
-	}
-
-	addSingleton(key, dependency) {
-		if (String.isNullOrEmpty(key))
-			throw Error(`Invalid injector key '${key}'.`);
-		if (!dependency)
-			throw Error('Invalid injector dependency.');
-
-		if (this._di[key])
-			return;
-
-		this._di[key] = { key: key, singleton: true, dependency: dependency };
-	}
-
-	getInjector() {
-		return this._di;
-	}
-
-	getService(key, args) {
-		if (String.isNullOrEmpty(key))
-			throw Error(`Invalid injector key '${key}'.`);
-
-		const result = this._di[key];
-		if (!result)
-			return null;
-
-		if (result.singleton)
-			return result.dependency;
-
-		return new result.dependency.prototype.constructor(args);
-	}
-
-	getServices() {
-		return Object.values(this._di);
-	}
-
-	getSingletons() {
-		return Object.values(this._di).filter(l => l.singleton).map(l => l.dependency);
-	}
-}
-
-const singletonInstance = new Injector();
-Object.freeze(singletonInstance);
-export default singletonInstance;
+class Injector {
+	constructor() {
+		this._di = {};
+	}
+
+	addService(key, dependency) {
+		if (String.isNullOrEmpty(key))
+			throw Error(`Invalid injector key '${key}'.`);
+		if (!dependency)
+			throw Error('Invalid injector dependency.');
+
+		if (this._di[key])
+			return;
+
+		this._di[key] = { dependency: dependency };
+	}
+
+	addSingleton(key, dependency) {
+		if (String.isNullOrEmpty(key))
+			throw Error(`Invalid injector key '${key}'.`);
+		if (!dependency)
+			throw Error('Invalid injector dependency.');
+
+		if (this._di[key])
+			return;
+
+		this._di[key] = { key: key, singleton: true, dependency: dependency };
+	}
+
+	getInjector() {
+		return this._di;
+	}
+
+	getService(key, args) {
+		if (String.isNullOrEmpty(key))
+			throw Error(`Invalid injector key '${key}'.`);
+
+		const result = this._di[key];
+		if (!result)
+			return null;
+
+		if (result.singleton)
+			return result.dependency;
+
+		return new result.dependency.prototype.constructor(args);
+	}
+
+	getServices() {
+		return Object.values(this._di);
+	}
+
+	getSingletons() {
+		return Object.values(this._di).filter(l => l.singleton).map(l => l.dependency);
+	}
+}
+
+const singletonInstance = new Injector();
+Object.freeze(singletonInstance);
+export default singletonInstance;

package/utility/internalIp/index.js

@@ -1,49 +1,49 @@
-import {networkInterfaces} from 'os';
-import defaultGateway from 'default-gateway';
-import ip from 'ipaddr.js';
-
-function findIp(gateway) {
-	const gatewayIp = ip.parse(gateway);
-
-	// Look for the matching interface in all local interfaces.
-	for (const addresses of Object.values(networkInterfaces())) {
-		for (const {cidr} of addresses) {
-			const net = ip.parseCIDR(cidr);
-
-			// eslint-disable-next-line unicorn/prefer-regexp-test
-			if (net[0] && net[0].kind() === gatewayIp.kind() && gatewayIp.match(net)) {
-				return net[0].toString();
-			}
-		}
-	}
-}
-
-async function async(family) {
-	try {
-		const {gateway} = await defaultGateway[family]();
-		return findIp(gateway);
-	} catch {}
-}
-
-function sync(family) {
-	try {
-		const {gateway} = defaultGateway[family].sync();
-		return findIp(gateway);
-	} catch {}
-}
-
-export async function internalIpV6() {
-	return async('v6');
-}
-
-export async function internalIpV4() {
-	return async('v4');
-}
-
-export function internalIpV6Sync() {
-	return sync('v6');
-}
-
-export function internalIpV4Sync() {
-	return sync('v4');
+import {networkInterfaces} from 'os';
+import defaultGateway from 'default-gateway';
+import ip from 'ipaddr.js';
+
+function findIp(gateway) {
+	const gatewayIp = ip.parse(gateway);
+
+	// Look for the matching interface in all local interfaces.
+	for (const addresses of Object.values(networkInterfaces())) {
+		for (const {cidr} of addresses) {
+			const net = ip.parseCIDR(cidr);
+
+			// eslint-disable-next-line unicorn/prefer-regexp-test
+			if (net[0] && net[0].kind() === gatewayIp.kind() && gatewayIp.match(net)) {
+				return net[0].toString();
+			}
+		}
+	}
+}
+
+async function async(family) {
+	try {
+		const {gateway} = await defaultGateway[family]();
+		return findIp(gateway);
+	} catch {}
+}
+
+function sync(family) {
+	try {
+		const {gateway} = defaultGateway[family].sync();
+		return findIp(gateway);
+	} catch {}
+}
+
+export async function internalIpV6() {
+	return async('v6');
+}
+
+export async function internalIpV4() {
+	return async('v4');
+}
+
+export function internalIpV6Sync() {
+	return sync('v6');
+}
+
+export function internalIpV4Sync() {
+	return sync('v4');
 }