Theaninova/openstapps
1
0
Fork 0
mirror of https://gitlab.com/openstapps/openstapps.git synced 2026-01-21 17:12:43 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

refactor: rebuild logger to be static

Browse Source 
Fixes #4
This commit is contained in:
Karl-Philipp Wulfert
2019-03-27 16:37:25 +01:00
committed by Karl-Philipp Wulfert
parent 7ef29ef56d
commit 1ae3beb347
4 changed files with 193 additions and 312 deletions
Download Patch File Download Diff File Expand all files Collapse all files

383
src/Logger.ts
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2018 StApps * Copyright (C) 2018, 2019 StApps
* This program is free software: you can redistribute it and/or modify it * This program is free software: you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the Free * under the terms of the GNU General Public License as published by the Free
* Software Foundation, version 3. * Software Foundation, version 3.
@@ -12,8 +12,10 @@
* You should have received a copy of the GNU General Public License along with * You should have received a copy of the GNU General Public License along with
* this program. If not, see <https://www.gnu.org/licenses/>. * this program. If not, see <https://www.gnu.org/licenses/>.
*/ */
import chalk from 'chalk';
import {stringify} from 'flatted'; import {stringify} from 'flatted';
import {Transport, TransportWithVerification} from './Transport'; import {isNodeEnvironment, isProductiveNodeEnvironment} from './common';
import {Transport} from './Transport';
/** /**
* Logger with colors, loglevel and transport * Logger with colors, loglevel and transport
@@ -23,189 +25,47 @@ import {Transport, TransportWithVerification} from './Transport';
* *
* Log levels in that order are: * Log levels in that order are:
* ``` * ```
* 1 - INFO * INFO: 1
* 2 - LOG * LOG: 2
* 4 - WARN * WARN: 4
* 8 - ERROR * ERROR: 8
* 16 - OK * OK: 16
* ``` * ```
*/ */
export class Logger { export class Logger {
/*
* Reset = "\x1b[0m"
* Bright = "\x1b[1m"
* Dim = "\x1b[2m"
* Underscore = "\x1b[4m"
* Blink = "\x1b[5m"
* Reverse = "\x1b[7m"
* Hidden = "\x1b[8m"
*
* FgBlack = "\x1b[30m"
* FgRed = "\x1b[31m"
* FgGreen = "\x1b[32m"
* FgYellow = "\x1b[33m"
* FgBlue = "\x1b[34m"
* FgMagenta = "\x1b[35m"
* FgCyan = "\x1b[36m"
* FgWhite = "\x1b[37m"
*
* BgBlack = "\x1b[40m"
* BgRed = "\x1b[41m"
* BgGreen = "\x1b[42m"
* BgYellow = "\x1b[43m"
* BgBlue = "\x1b[44m"
* BgMagenta = "\x1b[45m"
* BgCyan = "\x1b[46m"
* BgWhite = "\x1b[47m"
*/
/**
* Prefix for cyan color
*/
private cyan = '\x1b[36m';
/**
* Prefix for green color
*/
private green = '\x1b[32m';
/**
* Set to true if this code is executed by Node.js
*/
private isNode: boolean;
/**
* Set to true if the environment for a productive environment is given
*
* In Node.js this means that `NODE_ENV` is set to `production`
*/
private isProductiveEnvironment: boolean;
/** /**
* Log levels * Log levels
*/ */
private logLevels: { [logLevel: string]: 1 | 2 | 4 | 8 | 16 } = { private static logLevels = [
'INFO': 1, 'INFO',
'LOG': 2, 'LOG',
'WARN': 4, 'WARN',
// tslint:disable-next-line:object-literal-sort-keys 'ERROR',
'ERROR': 8, 'OK',
'OK': 16, ];
};
/**
* Prefix for red color
*/
private red = '\x1b[31m';
/**
* Suffix to end a color
*/
private reset = '\x1b[0m';
/** /**
* Transport for errors * Transport for errors
*
* For example `@stapps/smtp-transport`
*/ */
private transport?: Transport; private static transport?: Transport;
/**
* Prefix for white color
*/
private white = '\x1b[37m';
/**
* Prefix for yellow color
*/
private yellow = '\x1b[33m';
/**
* Checks if this code is executed in Node.js
*/
public static isNodeEnvironment(): boolean {
// Only Node.js has a process variable that is of [[Class]] process
return Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]';
}
/**
* Checks if a productive environment is given
*/
public static isProductiveEnvironment(): boolean {
return Logger.isNodeEnvironment &&
(typeof process.env.NODE_ENV === 'string' && process.env.NODE_ENV === 'production');
}
/**
* Instatiate an instance of logger
* @param transport A transport instance that can be used for error transport
*/
constructor(transport?: Transport) {
// node environment -> maybe we run a service which needs monitoring
if (Logger.isNodeEnvironment()) {
this.isNode = true;
// check if we are in productive environment -> then we need to run a transport
if (Logger.isProductiveEnvironment()) {
this.isProductiveEnvironment = true;
if (typeof transport === 'undefined') {
if (process.env.ALLOW_NO_TRANSPORT !== 'true') {
throw new Error('Productive environment doesn\'t set an transport agent for error notifications');
} else {
this.warn('Productive environment doesn\'t set an transport agent for error notifications');
}
} else {
this.transport = transport;
// we expect an transport for error notifications
if (this.isTransportWithVerification(transport) && !transport.isVerified()) {
transport.verify().then((success) => {
if (typeof success === 'string') {
this.ok(success);
} else {
this.ok('Successfully verified transport for error notification');
}
}).catch((err) => {
throw err;
});
}
}
} else {
this.isProductiveEnvironment = false;
}
} else {
this.isProductiveEnvironment = false;
this.isNode = false;
}
}
/** /**
* Check if intended log level is allowed in environment log level * Check if intended log level is allowed in environment log level
* *
* @param logLevel * @param logLevel
* @returns {boolean}
*/ */
private checkLogLevel(logLevel: 1 | 2 | 4 | 8 | 16) { private static checkLogLevel(logLevel: string): boolean {
const logLevelNumber = Math.pow(2, Logger.logLevels.indexOf(logLevel) + 1) - 1;
const requiredLogLevel = this.getLogLevel(); /* tslint:disable-next-line:no-bitwise */
return !!(Logger.getLogLevel() & logLevelNumber);
if (requiredLogLevel > 31 || requiredLogLevel < 0) {
throw new Error('Log level is out of range.');
}
// tslint:disable-next-line:no-bitwise
return requiredLogLevel & logLevel;
} }
/** /**
* Return log level from environment * Return log level from environment
* @returns {number}
*/ */
private getLogLevel(): number { private static getLogLevel(): number {
if (this.isNode && typeof process.env.STAPPS_LOG_LEVEL === 'string') { if (isNodeEnvironment() && typeof process.env.STAPPS_LOG_LEVEL !== 'undefined') {
// Node.js environment exists // Node.js environment exists
return parseInt(process.env.STAPPS_LOG_LEVEL, 10); return parseInt(process.env.STAPPS_LOG_LEVEL, 10);
} else if (typeof window !== 'undefined' && typeof (window as any).STAPPS_LOG_LEVEL === 'number') { } else if (typeof window !== 'undefined' && typeof (window as any).STAPPS_LOG_LEVEL === 'number') {
@@ -217,23 +77,102 @@ export class Logger {
return 31; return 31;
} }
private isTransportWithVerification(transport: Transport): transport is TransportWithVerification { /**
return typeof (transport as any).verify === 'function'; * Log an error
*
* @param args Arguments to log
*/
public static async error(...args: any[]): Promise<string | void> {
if (!Logger.checkLogLevel('ERROR')) {
return;
}
/* tslint:disable-next-line:no-console */
console.error(chalk.bold.red(`[ERROR] ${Logger.stringifyArguments(...args)}`));
if (isProductiveNodeEnvironment()) {
if (typeof Logger.transport !== 'undefined') {
return Logger.transport.send('Error', Logger.stringifyArguments(...args));
} else if (!process.env.ALLOW_NO_TRANSPORT) {
throw new Error(`Error couldn't be transported! Please set a transport or set ALLOW_NO_TRANSPORT='true'.`);
}
}
}
/**
* Log an information
*
* @param args Arguments to log
*/
public static info(...args: any[]): void {
if (!Logger.checkLogLevel('INFO')) {
return;
}
/* tslint:disable-next-line:no-console */
console.info(chalk.cyan(`[INFO] ${Logger.stringifyArguments(args)}`));
}
/**
* Check if the logger is initialized correctly
*/
public static initialized(): void {
if (isProductiveNodeEnvironment() && typeof Logger.transport === 'undefined') {
if (!process.env.ALLOW_NO_TRANSPORT) {
throw new Error(`Productive environment doesn't set a transport for error notifications.`);
} else {
/* tslint:disable-next-line:no-console */
console.warn(chalk.yellow(`Productive environment doesn't set a transport for error notifications.`));
}
}
}
/**
* Log something
*
* @param args Arguments to log
*/
public static log(...args: any[]): void {
if (!this.checkLogLevel('LOG')) {
return;
}
/* tslint:disable-next-line:no-console */
console.log(chalk.white(`[LOG] ${Logger.stringifyArguments(args)}`));
}
/**
* Log something successful
*
* @param args Arguments to log
*/
public static ok(...args: any[]): void {
if (!this.checkLogLevel('OK')) {
return;
}
/* tslint:disable-next-line:no-console */
console.log(chalk.bold.green(`[OK] ${Logger.stringifyArguments(args)}`));
}
/**
* Set a transport
*
* @param transport Transport to set
*/
public static setTransport(transport?: Transport) {
Logger.transport = transport;
} }
/** /**
* Stringify a list of arguments * Stringify a list of arguments
* *
* @param args {any[]} Arguments to stringify * @param args Arguments to stringify
* @returns {string} Stringified arguments
*/ */
private stringifyArguments(..._args: any[]): string { public static stringifyArguments(...args: any[]): string {
const result: string[] = []; const result: string[] = [];
/* tslint:disable:prefer-for-of */ args.forEach((argument) => {
for (let idx = 0; idx < arguments.length; idx++) {
/* tslint:enable */
const argument = arguments[idx];
const type = typeof argument; const type = typeof argument;
if (['string', 'number'].indexOf(type) !== -1) { if (['string', 'number'].indexOf(type) !== -1) {
@@ -246,106 +185,22 @@ export class Logger {
} else { } else {
result.push(stringify(argument, null, 2)); result.push(stringify(argument, null, 2));
} }
} });
return result.join(', '); return result.join(', ');
} }
/** /**
* Log with level ERROR * Log a warning
* *
* @param args {any} Arguments to log * @param args Arguments to log
*/ */
public error(...args: any[]): void { public static warn(...args: any[]): void {
if (this.checkLogLevel(this.logLevels.ERROR)) { if (!this.checkLogLevel('WARN')) {
if (this.isNode) { return;
/* tslint:disable-next-line:no-console */
console.error(this.red + '[ERROR] ' + this.stringifyArguments(...args) + this.reset);
if (this.isProductiveEnvironment) {
if (typeof this.transport === 'undefined') {
if (process.env.ALLOW_NO_TRANSPORT !== 'true') {
throw new Error('Error couldn\'t be tranported. Please set an transport or set ALLOW_NO_TRANSPORT=true');
}
} else {
this.transport.send('Error', this.stringifyArguments(...args)).catch((err) => {
throw err;
});
}
}
} else {
/* tslint:disable-next-line:no-console */
console.log('[ERROR] ' + this.stringifyArguments(...args));
}
} }
}
/** /* tslint:disable-next-line:no-console */
* Log with level INFO console.warn(chalk.yellow(`[WARN] ${Logger.stringifyArguments(args)}`));
*
* @param args {any} Arguments to log
*/
public info(...args: any[]): void {
if (this.checkLogLevel(this.logLevels.INFO)) {
if (this.isNode) {
/* tslint:disable-next-line:no-console */
console.info(this.cyan + '[INFO] ' + this.stringifyArguments(...args) + this.reset);
} else {
/* tslint:disable-next-line:no-console */
console.info('[INFO] ' + this.stringifyArguments(...args));
}
}
}
/**
* Log with level LOG
*
* @param args {any} Arguments to log
*/
public log(...args: any[]): void {
if (this.checkLogLevel(this.logLevels.LOG)) {
if (this.isNode) {
/* tslint:disable-next-line:no-console */
console.log(this.white + '[LOG] ' + this.stringifyArguments(...args) + this.reset);
} else {
/* tslint:disable-next-line:no-console */
console.log('[LOG] ' + this.stringifyArguments(...args));
}
}
}
/**
* Log with level OK
*
* @param args {any} Arguments to log
*/
public ok(...args: any[]): void {
if (this.checkLogLevel(this.logLevels.OK)) {
if (this.isNode) {
/* tslint:disable-next-line:no-console */
console.log(this.green + '[OK] ' + this.stringifyArguments(...args) + this.reset);
} else {
/* tslint:disable-next-line:no-console */
console.log('[OK] ' + this.stringifyArguments(...args));
}
}
}
/**
* Log with level WARN
*
* @param args {any} Arguments to log
*/
public warn(...args: any[]): void {
if (this.checkLogLevel(this.logLevels.WARN)) {
if (this.isNode) {
/* tslint:disable-next-line:no-console */
console.warn(this.yellow + '[WARN] ' + this.stringifyArguments(...args) + this.reset);
} else {
/* tslint:disable-next-line:no-console */
console.warn('[WARN] ' + this.stringifyArguments(...args));
}
}
} }
} }

47
src/SMTP.ts
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2018 StApps * Copyright (C) 2018, 2019 StApps
* This program is free software: you can redistribute it and/or modify it * This program is free software: you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the Free * under the terms of the GNU General Public License as published by the Free
* Software Foundation, version 3. * Software Foundation, version 3.
@@ -14,9 +14,8 @@
*/ */
import * as nodemailer from 'nodemailer'; import * as nodemailer from 'nodemailer';
import {MailOptions} from 'nodemailer/lib/sendmail-transport'; import {MailOptions} from 'nodemailer/lib/sendmail-transport';
import {deleteUndefinedProperties, RecursivePartial} from './common'; import {deleteUndefinedProperties, isProductiveEnvironment, RecursivePartial} from './common';
import {Logger} from './Logger'; import {VerifiableTransport} from './Transport';
import {TransportWithVerification} from './Transport';
/** /**
* A configuration of the transport used to send mails via SMTP * A configuration of the transport used to send mails via SMTP
@@ -40,14 +39,14 @@ export interface SMTPConfig {
/** /**
* An implementation of mail transport via SMTP * An implementation of mail transport via SMTP
*/ */
export class SMTP extends TransportWithVerification { export class SMTP extends VerifiableTransport {
private static _instance: SMTP; private static _instance: SMTP;
/** /**
* List of all mail addresses to send in cc * List of all mail addresses to send in cc
*/ */
private cc: string[]; private readonly cc: string[];
/** /**
* Who is using this service * Who is using this service
@@ -60,7 +59,7 @@ export class SMTP extends TransportWithVerification {
/** /**
* List of all mail addresses to send to * List of all mail addresses to send to
*/ */
private recipients: string[]; private readonly recipients: string[];
/** /**
* Connection to SMTP server * Connection to SMTP server
@@ -95,7 +94,7 @@ export class SMTP extends TransportWithVerification {
} }
// monitoring is not required -> SMTP init can fail // monitoring is not required -> SMTP init can fail
if (!Logger.isProductiveEnvironment() || process.env.ALLOW_NO_TRANSPORT === 'true') { if (!isProductiveEnvironment() || process.env.ALLOW_NO_TRANSPORT === 'true') {
try { try {
this._instance = new this(config); this._instance = new this(config);
} catch (err) { } catch (err) {
@@ -122,14 +121,8 @@ export class SMTP extends TransportWithVerification {
* @return {boolean} * @return {boolean}
*/ */
public static isValidEmailAddress(address: string): boolean { public static isValidEmailAddress(address: string): boolean {
if (typeof address !== 'string') {
return false;
}
// tslint:disable-next-line:max-line-length // tslint:disable-next-line:max-line-length
const regex = /^(([^<>()\[\]\.,;:\s@\"]+(\.[^<>()\[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i; return /^(([^<>()\[\].,;:\s@"]+(\.[^<>()\[\].,;:\s@"]+)*)|(".+"))@(([^<>()[\].,;:\s@"]+\.)+[^<>()[\].,;:\s@"]{2,})$/i.test(address);
return regex.test(address);
} }
/** /**
@@ -153,13 +146,13 @@ export class SMTP extends TransportWithVerification {
password: process.env.SMTP_AUTH_PASSWORD, password: process.env.SMTP_AUTH_PASSWORD,
user: process.env.SMTP_AUTH_USER, user: process.env.SMTP_AUTH_USER,
}, },
cc: ((typeof process.env.SMTP_CC === 'string') ? (process.env.SMTP_CC as string).split(',') : []), cc: ((typeof process.env.SMTP_CC !== 'undefined') ? (process.env.SMTP_CC as string).split(',') : []),
host: process.env.SMTP_HOST, host: process.env.SMTP_HOST,
port: (typeof process.env.SMTP_PORT === 'string') ? parseInt(process.env.SMTP_PORT, 10) : undefined, port: (typeof process.env.SMTP_PORT !== 'undefined') ? parseInt(process.env.SMTP_PORT, 10) : undefined,
recipients: (typeof process.env.SMTP_RECIPIENTS === 'string') ? recipients: (typeof process.env.SMTP_RECIPIENTS !== 'undefined') ?
(process.env.SMTP_RECIPIENTS).split(',') : (process.env.SMTP_RECIPIENTS).split(',') :
[], [],
secure: (typeof process.env.SMTP_SECURE === 'string') ? (process.env.SMTP_SECURE === 'true') : false, secure: (typeof process.env.SMTP_SECURE !== 'undefined') ? (process.env.SMTP_SECURE === 'true') : false,
sender: { sender: {
mail: process.env.SMTP_SENDER_MAIL, mail: process.env.SMTP_SENDER_MAIL,
name: process.env.SMTP_SENDER_NAME, name: process.env.SMTP_SENDER_NAME,
@@ -173,13 +166,13 @@ export class SMTP extends TransportWithVerification {
...deleteUndefinedProperties(envConfig), ...deleteUndefinedProperties(envConfig),
}; };
if (typeof config!.host !== 'string') { if (typeof config!.host === 'undefined') {
throw new Error( throw new Error(
'SMTP configuration needs a host. Add it to the config or use environment variables (SMTP_HOST).', 'SMTP configuration needs a host. Add it to the config or use environment variables (SMTP_HOST).',
); );
} }
if (typeof config!.port !== 'number' || isNaN(config!.port)) { if (typeof config!.port === 'undefined' || isNaN(config!.port)) {
throw new Error( throw new Error(
'SMTP configuration needs a port. Add it to the config or use environment variables (SMTP_PORT).', 'SMTP configuration needs a port. Add it to the config or use environment variables (SMTP_PORT).',
); );
@@ -192,13 +185,13 @@ export class SMTP extends TransportWithVerification {
); );
} }
if (typeof config!.auth.user !== 'string') { if (typeof config!.auth.user === 'undefined') {
throw new Error( throw new Error(
'SMTP auth configuration needs a user. Add it to the config or use environment variables (SMTP_AUTH_USER).', 'SMTP auth configuration needs a user. Add it to the config or use environment variables (SMTP_AUTH_USER).',
); );
} }
if (typeof config!.auth.password !== 'string') { if (typeof config!.auth.password === 'undefined') {
throw new Error( throw new Error(
'SMTP auth configuration needs a password.' + 'SMTP auth configuration needs a password.' +
'Add it to the config or use environment variables (SMTP_AUTH_PASSWORD).', 'Add it to the config or use environment variables (SMTP_AUTH_PASSWORD).',
@@ -211,7 +204,7 @@ export class SMTP extends TransportWithVerification {
); );
} }
if (typeof config!.sender.mail !== 'string') { if (typeof config!.sender.mail === 'undefined') {
throw new Error( throw new Error(
'SMTP configuration needs a sender. Add it to the config or use environment variables (SMTP_SENDER_MAIL).', 'SMTP configuration needs a sender. Add it to the config or use environment variables (SMTP_SENDER_MAIL).',
); );
@@ -247,7 +240,7 @@ export class SMTP extends TransportWithVerification {
}, },
host: config!.host, host: config!.host,
port: config!.port, port: config!.port,
secure: typeof config!.secure === 'boolean' ? config!.secure : false, secure: typeof config!.secure !== 'undefined' ? config!.secure : false,
}); });
} }
@@ -311,7 +304,7 @@ export class SMTP extends TransportWithVerification {
try { try {
verificationSuccessfull = await this.transportAgent.verify(); verificationSuccessfull = await this.transportAgent.verify();
} catch (err) { } catch (err) {
if (!Logger.isProductiveEnvironment() || process.env.ALLOW_NO_TRANSPORT !== 'true') { if (!isProductiveEnvironment() || process.env.ALLOW_NO_TRANSPORT !== 'true') {
throw err; throw err;
} else { } else {
/* tslint:disable-next-line:no-console */ /* tslint:disable-next-line:no-console */
@@ -323,7 +316,7 @@ export class SMTP extends TransportWithVerification {
} }
if (!verificationSuccessfull) { if (!verificationSuccessfull) {
if (!Logger.isProductiveEnvironment() || process.env.ALLOW_NO_TRANSPORT !== 'true') { if (!isProductiveEnvironment() || process.env.ALLOW_NO_TRANSPORT !== 'true') {
throw new Error( throw new Error(
'Verification of SMTP transport failed.' + 'Verification of SMTP transport failed.' +
'If you want to ignore this error set' + 'If you want to ignore this error set' +

27
src/Transport.ts
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2018 StApps * Copyright (C) 2018, 2019 StApps
* This program is free software: you can redistribute it and/or modify it * This program is free software: you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the Free * under the terms of the GNU General Public License as published by the Free
* Software Foundation, version 3. * Software Foundation, version 3.
@@ -14,34 +14,33 @@
*/ */
/** /**
* An abstract wrapper for a transport system like for example smtp * An abstract wrapper for a transport system like for example SMTP
*/ */
export abstract class Transport { export abstract class Transport {
/** /**
* Send message with subject. A message can be a mail or something completly different. Depending on what Transport * Send message with subject
* is implemented *
* @param {string} subject * A message can be a mail or something completely different depending on what transport is implemented.
* @param {string} message *
* @param subject Subject of the message
* @param message Message to send
*/ */
abstract send(subject: string, message: string): Promise<string>; abstract send(subject: string, message: string): Promise<string>;
} }
/** /**
* A transport wrapper of transport which can be veriefied * A transport wrapper of transport which can be verified
*/ */
export abstract class TransportWithVerification extends Transport { export abstract class VerifiableTransport extends Transport {
/** /**
* Checks if the transport was verified at least once * Checks if the transport was verified at least once
* @returns {boolean}
*/ */
abstract isVerified(): boolean; abstract isVerified(): boolean;
/** /**
* Verifies transport (check connection, authentication, ...) * Verifies transport
*
* Check connection, authentication, ...
*/ */
abstract verify(): Promise<boolean>; abstract verify(): Promise<boolean>;
} }

48
src/common.ts
View File

@@ -13,15 +13,17 @@
* this program. If not, see <https://www.gnu.org/licenses/>. * this program. If not, see <https://www.gnu.org/licenses/>.
*/ */
/** /**
* A recursive partial object * A recursive partial object
* *
* Copied from https://stackoverflow.com/a/51365037 * Copied from https://stackoverflow.com/a/51365037
*/ */
import {Transport, VerifiableTransport} from './Transport';
export type RecursivePartial<T> = { export type RecursivePartial<T> = {
[P in keyof T]?: T[P] extends Array<infer U> ? [P in keyof T]?: T[P] extends Array<infer U> ?
Array<RecursivePartial<U>> : Array<RecursivePartial<U>> :
T[P] extends object ? RecursivePartial<T[P]> : T[P]; T[P] extends object ? RecursivePartial<T[P]> : T[P];
}; };
/** /**
@@ -47,3 +49,35 @@ export function deleteUndefinedProperties(obj: any) {
return obj; return obj;
} }
/**
* Checks if environment is Node.js
*/
export function isNodeEnvironment(): boolean {
return Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]';
}
/**
* Checks if environment is productive
*/
export function isProductiveEnvironment(): boolean {
return typeof process.env === 'object'
&& typeof process.env.NODE_ENV !== 'undefined'
&& process.env.NODE_ENV === 'production';
}
/**
* Checks if environment is Node.js and productive
*/
export function isProductiveNodeEnvironment(): boolean {
return isNodeEnvironment() && isProductiveEnvironment();
}
/**
* Check if a transport is a verifiable transport
*
* @param transport Transport to check
*/
export function isTransportWithVerification(transport: Transport): transport is VerifiableTransport {
return transport instanceof VerifiableTransport;
}