Merge pull request #16983 from elyscape/feature/improve-bunyan

[bunyan] Significantly improve type declarations

types/bunyan/bunyan-tests.ts

@@ -1,16 +1,15 @@
-
 import Logger = require('bunyan');
 
-var ringBufferOptions: Logger.RingBufferOptions = {
+let ringBufferOptions: Logger.RingBufferOptions = {
     limit: 100
 };
-var ringBuffer: Logger.RingBuffer = new Logger.RingBuffer(ringBufferOptions);
+let ringBuffer: Logger.RingBuffer = new Logger.RingBuffer(ringBufferOptions);
 ringBuffer.write("hello");
 ringBuffer.end();
 ringBuffer.destroy();
 ringBuffer.destroySoon();
 
-var level: number;
+let level: number;
 level = Logger.resolveLevel("trace");
 level = Logger.resolveLevel("debug");
 level = Logger.resolveLevel("info");
@@ -24,7 +23,7 @@ level = Logger.resolveLevel(Logger.WARN);
 level = Logger.resolveLevel(Logger.ERROR);
 level = Logger.resolveLevel(Logger.FATAL);
 
-var options: Logger.LoggerOptions = {
+let options: Logger.LoggerOptions = {
     name: 'test-logger',
     serializers: Logger.stdSerializers,
     streams: [{
@@ -54,13 +53,13 @@ var options: Logger.LoggerOptions = {
     }]
 };
 
-var log = Logger.createLogger(options);
+let log = Logger.createLogger(options);
 
-var customSerializer = function(anything: any) {
-    return { obj: anything};
+let customSerializer = (anything: any) => {
+    return { obj: anything };
 };
 
-log.addSerializers({anything: customSerializer});
+log.addSerializers({ anything: customSerializer });
 log.addSerializers(Logger.stdSerializers);
 log.addSerializers(
     {
@@ -70,9 +69,9 @@ log.addSerializers(
     }
 );
 
-var child = log.child({name: 'child'});
+let child = log.child({ name: 'child' });
 child.reopenFileStreams();
-log.addStream({path: '/dev/null'});
+log.addStream({ path: '/dev/null' });
 child.level(Logger.DEBUG);
 child.level('debug');
 child.levels(0, Logger.ERROR);
@@ -80,9 +79,9 @@ child.levels(0, 'error');
 child.levels('stream1', Logger.FATAL);
 child.levels('stream1', 'fatal');
 
-var buffer = new Buffer(0);
-var error = new Error('');
-var object = {
+let buffer = new Buffer(0);
+let error = new Error('');
+let object = {
     test: 123
 };
 
@@ -117,12 +116,11 @@ log.fatal(error);
 log.fatal(object);
 log.fatal('Hello, %s', 'world!');
 
-var recursive: any = {
+let recursive: any = {
     hello: 'world',
-    whats: {
-        huh: recursive
-    }
-}
+    whats: {}
+};
+recursive.whats['huh'] = recursive;
 
 JSON.stringify(recursive, Logger.safeCycles());
 

types/bunyan/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for node-bunyan
+// Type definitions for node-bunyan 1.8
 // Project: https://github.com/trentm/node-bunyan
 // Definitions by: Alex Mikhalev <https://github.com/amikhalev>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
@@ -10,21 +10,24 @@ import { EventEmitter } from 'events';
 declare class Logger extends EventEmitter {
     constructor(options: Logger.LoggerOptions);
     addStream(stream: Logger.Stream): void;
-    addSerializers(serializers: Logger.Serializers | Logger.StdSerializers): void;
-    child(options: Logger.LoggerOptions, simple?: boolean): Logger;
-    child(obj: Object, simple?: boolean): Logger;
+    addSerializers(serializers: Logger.Serializers): void;
+    child(options: Object, simple?: boolean): Logger;
     reopenFileStreams(): void;
 
-    level(): string | number;
-    level(value: number | string): void;
-    levels(name: number | string, value: number | string): void;
+    level(): number;
+    level(value: Logger.LogLevel): void;
+    levels(): number[];
+    levels(name: number | string): number;
+    levels(name: number | string, value: Logger.LogLevel): void;
 
     fields: any;
     src: boolean;
 
+    /* tslint:disable:unified-signatures */
+
     /**
      * Returns a boolean: is the `trace` level enabled?
-     * 
+     *
      * This is equivalent to `log.isTraceEnabled()` or `log.isEnabledFor(TRACE)` in log4j.
      */
     trace(): boolean;
@@ -35,27 +38,25 @@ declare class Logger extends EventEmitter {
      * (including the stack) and sets `msg` to the exception
      * message or you can specify the `msg`.
      */
-    trace(error: Error, format?: any, ...params: any[]): void;
-
-    trace(buffer: Buffer, format?: any, ...params: any[]): void;
-
-    /**
-     * Uses `util.format` for msg formatting.
-     */
-    trace(format: string | number, ...params: any[]): void;
+    trace(error: Error, ...params: any[]): void;
 
     /**
      * The first field can optionally be a "fields" object, which
      * is merged into the log record.
-     * 
+     *
      * To pass in an Error *and* other fields, use the `err`
      * field name for the Error instance.
      */
-    trace(obj: Object, format?: any, ...params: any[]): void;
+    trace(obj: Object, ...params: any[]): void;
+
+    /**
+     * Uses `util.format` for msg formatting.
+     */
+    trace(format: any, ...params: any[]): void;
 
     /**
      * Returns a boolean: is the `debug` level enabled?
-     * 
+     *
      * This is equivalent to `log.isDebugEnabled()` or `log.isEnabledFor(DEBUG)` in log4j.
      */
     debug(): boolean;
@@ -66,27 +67,25 @@ declare class Logger extends EventEmitter {
      * (including the stack) and sets `msg` to the exception
      * message or you can specify the `msg`.
      */
-    debug(error: Error, format?: any, ...params: any[]): void;
-
-    debug(buffer: Buffer, format?: any, ...params: any[]): void;
-
-    /**
-     * Uses `util.format` for msg formatting.
-     */
-    debug(format: string | number, ...params: any[]): void;
+    debug(error: Error, ...params: any[]): void;
 
     /**
      * The first field can optionally be a "fields" object, which
      * is merged into the log record.
-     * 
+     *
      * To pass in an Error *and* other fields, use the `err`
      * field name for the Error instance.
      */
-    debug(obj: Object, format?: any, ...params: any[]): void;
+    debug(obj: Object, ...params: any[]): void;
+
+    /**
+     * Uses `util.format` for msg formatting.
+     */
+    debug(format: any, ...params: any[]): void;
 
     /**
      * Returns a boolean: is the `info` level enabled?
-     * 
+     *
      * This is equivalent to `log.isInfoEnabled()` or `log.isEnabledFor(INFO)` in log4j.
      */
     info(): boolean;
@@ -97,27 +96,25 @@ declare class Logger extends EventEmitter {
      * (including the stack) and sets `msg` to the exception
      * message or you can specify the `msg`.
      */
-    info(error: Error, format?: any, ...params: any[]): void;
-
-    info(buffer: Buffer, format?: any, ...params: any[]): void;
-
-    /**
-     * Uses `util.format` for msg formatting.
-     */
-    info(format: string | number, ...params: any[]): void;
+    info(error: Error, ...params: any[]): void;
 
     /**
      * The first field can optionally be a "fields" object, which
      * is merged into the log record.
-     * 
+     *
      * To pass in an Error *and* other fields, use the `err`
      * field name for the Error instance.
      */
-    info(obj: Object, format?: any, ...params: any[]): void;
+    info(obj: Object, ...params: any[]): void;
+
+    /**
+     * Uses `util.format` for msg formatting.
+     */
+    info(format: any, ...params: any[]): void;
 
     /**
      * Returns a boolean: is the `warn` level enabled?
-     * 
+     *
      * This is equivalent to `log.isWarnEnabled()` or `log.isEnabledFor(WARN)` in log4j.
      */
     warn(): boolean;
@@ -128,27 +125,25 @@ declare class Logger extends EventEmitter {
      * (including the stack) and sets `msg` to the exception
      * message or you can specify the `msg`.
      */
-    warn(error: Error, format?: any, ...params: any[]): void;
-
-    warn(buffer: Buffer, format?: any, ...params: any[]): void;
-
-    /**
-     * Uses `util.format` for msg formatting.
-     */
-    warn(format: string | number, ...params: any[]): void;
+    warn(error: Error, ...params: any[]): void;
 
     /**
      * The first field can optionally be a "fields" object, which
      * is merged into the log record.
-     * 
+     *
      * To pass in an Error *and* other fields, use the `err`
      * field name for the Error instance.
      */
-    warn(obj: Object, format?: any, ...params: any[]): void;
+    warn(obj: Object, ...params: any[]): void;
+
+    /**
+     * Uses `util.format` for msg formatting.
+     */
+    warn(format: any, ...params: any[]): void;
 
     /**
      * Returns a boolean: is the `error` level enabled?
-     * 
+     *
      * This is equivalent to `log.isErrorEnabled()` or `log.isEnabledFor(ERROR)` in log4j.
      */
     error(): boolean;
@@ -159,27 +154,25 @@ declare class Logger extends EventEmitter {
      * (including the stack) and sets `msg` to the exception
      * message or you can specify the `msg`.
      */
-    error(error: Error, format?: any, ...params: any[]): void;
-
-    error(buffer: Buffer, format?: any, ...params: any[]): void;
-
-    /**
-     * Uses `util.format` for msg formatting.
-     */
-    error(format: string | number, ...params: any[]): void;
+    error(error: Error, ...params: any[]): void;
 
     /**
      * The first field can optionally be a "fields" object, which
      * is merged into the log record.
-     * 
+     *
      * To pass in an Error *and* other fields, use the `err`
      * field name for the Error instance.
      */
-    error(obj: Object, format?: any, ...params: any[]): void;
+    error(obj: Object, ...params: any[]): void;
+
+    /**
+     * Uses `util.format` for msg formatting.
+     */
+    error(format: any, ...params: any[]): void;
 
     /**
      * Returns a boolean: is the `fatal` level enabled?
-     * 
+     *
      * This is equivalent to `log.isFatalEnabled()` or `log.isEnabledFor(FATAL)` in log4j.
      */
     fatal(): boolean;
@@ -190,90 +183,90 @@ declare class Logger extends EventEmitter {
      * (including the stack) and sets `msg` to the exception
      * message or you can specify the `msg`.
      */
-    fatal(error: Error, format?: any, ...params: any[]): void;
-
-    fatal(buffer: Buffer, format?: any, ...params: any[]): void;
-
-    /**
-     * Uses `util.format` for msg formatting.
-     */
-    fatal(format: string | number, ...params: any[]): void;
+    fatal(error: Error, ...params: any[]): void;
 
     /**
      * The first field can optionally be a "fields" object, which
      * is merged into the log record.
-     * 
+     *
      * To pass in an Error *and* other fields, use the `err`
      * field name for the Error instance.
      */
-    fatal(obj: Object, format?: any, ...params: any[]): void;
+    fatal(obj: Object, ...params: any[]): void;
+
+    /**
+     * Uses `util.format` for msg formatting.
+     */
+    fatal(format: any, ...params: any[]): void;
+
+    /* tslint:enable:unified-signatures */
 }
 
 declare namespace Logger {
-  const TRACE: number;
-  const DEBUG: number;
-  const INFO: number;
-  const WARN: number;
-  const ERROR: number;
-  const FATAL: number;
+    const TRACE: number;
+    const DEBUG: number;
+    const INFO: number;
+    const WARN: number;
+    const ERROR: number;
+    const FATAL: number;
 
-  const stdSerializers: StdSerializers;
+    type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal' | number;
 
-  function createLogger(options: LoggerOptions): Logger;
+    const stdSerializers: StdSerializers;
 
-  function safeCycles(): (key: string, value: any) => any;
+    function createLogger(options: LoggerOptions): Logger;
 
-  function resolveLevel(value: number | string): number;
+    function safeCycles(): (key: string, value: any) => any;
 
-  interface Stream {
-    type?: string;
-    level?: number | string;
-    path?: string;
-    stream?: NodeJS.WritableStream | Stream;
-    closeOnExit?: boolean;
-    period?: string;
-    count?: number;
-  }
+    function resolveLevel(value: LogLevel): number;
 
-  interface LoggerOptions {
-    name: string;
-    streams?: Stream[];
-    level?: string | number;
-    stream?: NodeJS.WritableStream;
-    serializers?: Serializers | StdSerializers;
-    src?: boolean;
-    [custom: string]: any;
-  }
+    interface Stream {
+        type?: string;
+        level?: LogLevel;
+        path?: string;
+        stream?: NodeJS.WritableStream | Stream;
+        closeOnExit?: boolean;
+        period?: string;
+        count?: number;
+    }
 
-  interface Serializer {
-    (input:any): any;
-  }
+    interface LoggerOptions {
+        name: string;
+        streams?: Stream[];
+        level?: LogLevel;
+        stream?: NodeJS.WritableStream;
+        serializers?: Serializers;
+        src?: boolean;
+        [custom: string]: any;
+    }
 
-  interface Serializers {
-    [key: string]: Serializer
-  }
+    type Serializer = (input: any) => any;
 
-  interface StdSerializers {
-    err: Serializer;
-    res: Serializer;
-    req: Serializer;
-  }
+    interface Serializers {
+        [key: string]: Serializer;
+    }
 
-  interface RingBufferOptions {
-    limit?: number;
-  }
+    interface StdSerializers extends Serializers {
+        err: Serializer;
+        res: Serializer;
+        req: Serializer;
+    }
 
-  class RingBuffer extends EventEmitter implements NodeJS.WritableStream {
-    constructor(options: RingBufferOptions);
+    interface RingBufferOptions {
+        limit?: number;
+    }
 
-    writable: boolean;
-    records: any[];
+    class RingBuffer extends EventEmitter implements NodeJS.WritableStream {
+        constructor(options: RingBufferOptions);
 
-    write(record: any): boolean;
-    end(record?: any): void;
-    destroy(): void;
-    destroySoon(): void;
-  }
+        writable: boolean;
+        records: any[];
+
+        write(record: any): boolean;
+        end(record?: any): void;
+        destroy(): void;
+        destroySoon(): void;
+    }
 }
 
 export = Logger;

types/bunyan/tslint.json

@@ -0,0 +1,7 @@
+{
+  "extends": "dtslint/dt.json",
+  "rules": {
+    // ban-types needs to be disabled to support TypeScript <2.2
+    "ban-types": false
+  }
+}