typescript, tests and lint

Author: afonsof

.npmignore

@@ -0,0 +1,2 @@
+tsconfig.json
+src

dist/index.d.ts

@@ -0,0 +1,2 @@
+import * as winston from 'winston';
+export declare const loggerFactory: ({ config }: import("./logger-factory-generator").IFactoryInterface) => winston.Logger;

dist/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const winston = require("winston");
+const winston_sentry_raven_transport_1 = require("winston-sentry-raven-transport");
+const logger_factory_generator_1 = require("./logger-factory-generator");
+exports.loggerFactory = logger_factory_generator_1.loggerFactoryGenerator({
+    winston,
+    consoleTransportClass: winston.transports.Console,
+    sentryTransportClass: winston_sentry_raven_transport_1.default,
+});

dist/logger-factory-generator.d.ts

@@ -0,0 +1,18 @@
+import { Logger } from 'winston';
+declare interface IConfig {
+    sentry: {
+        enabled: boolean;
+        dsn?: string;
+        level?: string;
+    };
+}
+export interface IFactoryInterface {
+    config: IConfig;
+}
+declare type LoggerFactoryType = ({ config }: IFactoryInterface) => Logger;
+export declare const loggerFactoryGenerator: ({ winston, consoleTransportClass, sentryTransportClass }: {
+    winston: any;
+    consoleTransportClass: any;
+    sentryTransportClass: any;
+}) => LoggerFactoryType;
+export {};

dist/logger-factory-generator.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const moment = require("moment");
+function prepareErrorToLog(error, messages = []) {
+    if (messages.length) {
+        error.message = `${error.message} :: ${messages.join(',')}`;
+    }
+    return error;
+}
+exports.loggerFactoryGenerator = ({ winston, consoleTransportClass, sentryTransportClass }) => {
+    return ({ config }) => {
+        const transports = [];
+        transports.push(new consoleTransportClass({
+            level: config.sentry.level,
+        }));
+        if (config.sentry.enabled) {
+            transports.push(new sentryTransportClass({
+                dsn: config.sentry.dsn,
+                level: 'error',
+            }));
+        }
+        const logger = winston.createLogger({
+            format: winston.format.printf(error => `${moment.utc().format('YYYY-MM-DD HH:mm Z')} [${error.level}]: ${error.message}`),
+            transports,
+            exitOnError: false,
+        });
+        const errorFn = logger.error;
+        logger.error = (...args) => {
+            if (!args || !args.length)
+                return;
+            let error;
+            const messages = [];
+            let object = {};
+            args.forEach((arg) => {
+                if (arg instanceof Error) {
+                    error = arg;
+                }
+                else if (typeof arg === 'string') {
+                    messages.push(arg);
+                }
+                else if (typeof arg === 'object') {
+                    object = Object.assign({}, object, arg);
+                }
+            });
+            if (error) {
+                return errorFn(prepareErrorToLog(error, messages), Object.assign({}, object, { stack: error.stack }));
+            }
+            else {
+                return errorFn.apply(logger, args);
+            }
+        };
+        return logger;
+    };
+};

dist/logger-factory-generator.test.d.ts

@@ -0,0 +1 @@
+export {};

dist/logger-factory-generator.test.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const winston = require("winston");
+const logger_factory_generator_1 = require("./logger-factory-generator");
+const TransportStream = require("winston-transport");
+let lastSentryLog;
+class FakeSentryTransport extends TransportStream {
+    log(info) {
+        lastSentryLog = info;
+    }
+}
+let lastConsoleLog;
+class FakeConsoleTransport extends TransportStream {
+    log(info) {
+        lastConsoleLog = info;
+    }
+}
+let logger;
+const symbolMessage = Symbol.for('message');
+const symbolLevel = Symbol.for('level');
+describe('gupy-logger', () => {
+    beforeEach(() => {
+        lastConsoleLog = null;
+        lastSentryLog = null;
+        const loggerFactory = logger_factory_generator_1.loggerFactoryGenerator({
+            winston,
+            consoleTransportClass: FakeConsoleTransport,
+            sentryTransportClass: FakeSentryTransport
+        });
+        logger = loggerFactory({
+            config: { sentry: { enabled: true, dsn: 'any', level: 'info' } }
+        });
+    });
+    it('should log debug nowhere', () => {
+        logger.debug('any info');
+        chai_1.expect(lastSentryLog).to.equal(null);
+        chai_1.expect(lastConsoleLog).to.deep.equal(null);
+        chai_1.expect(lastSentryLog).to.deep.equal(null);
+    });
+    it('should log info only at console', () => {
+        logger.info('any info');
+        chai_1.expect(lastSentryLog).to.equal(null);
+        chai_1.expect(lastConsoleLog).to.deep.equal({
+            level: 'info',
+            message: 'any info'
+        });
+        chai_1.expect(lastConsoleLog[symbolMessage]).to.match(/\d{4}-\d{2}-\d{2} \d{2}:\d{2} \+\d{2}:\d{2} \[info]: any info/);
+        chai_1.expect(lastConsoleLog[symbolLevel]).to.equal('info');
+    });
+    it('should log warn only at console', () => {
+        logger.warn('any warn');
+        chai_1.expect(lastSentryLog).to.equal(null);
+        chai_1.expect(lastConsoleLog).to.deep.equal({
+            level: 'warn',
+            message: 'any warn'
+        });
+        chai_1.expect(lastConsoleLog[symbolMessage]).to.match(/\d{4}-\d{2}-\d{2} \d{2}:\d{2} \+\d{2}:\d{2} \[warn]: any warn/);
+        chai_1.expect(lastConsoleLog[symbolLevel]).to.equal('warn');
+    });
+    it('should log error at sentry and console', () => {
+        logger.error('any error');
+        chai_1.expect(lastSentryLog).to.deep.equal({
+            level: 'error',
+            message: 'any error'
+        });
+        chai_1.expect(lastSentryLog[symbolMessage]).to.match(/\d{4}-\d{2}-\d{2} \d{2}:\d{2} \+\d{2}:\d{2} \[error]: any error/);
+        chai_1.expect(lastSentryLog[symbolLevel]).to.equal('error');
+        chai_1.expect(lastConsoleLog).to.be.deep.equal({
+            level: 'error',
+            message: 'any error'
+        });
+        chai_1.expect(lastConsoleLog[symbolMessage]).to.match(/\d{4}-\d{2}-\d{2} \d{2}:\d{2} \+\d{2}:\d{2} \[error]: any error/);
+        chai_1.expect(lastConsoleLog[symbolLevel]).to.equal('error');
+    });
+});