Merge pull request #12850 from evanshortiss/types-2.0

updates for pino module

pino/index.d.ts

@@ -1,86 +1,95 @@
-// Type definitions for pino v1.0.1
+// Type definitions for pino v3.0.1
 // Project: https://github.com/mcollina/pino.git
 // Definitions by: Peter Snider <https://github.com/psnider>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 /// <reference types="node"/>
 
-declare module 'pino' {
+import stream = require('stream');
 
-    import stream = require('stream')
+declare function P(optionsOrStream?: P.LoggerOptions | stream.Writable | stream.Duplex | stream.Transform): P.Logger;
+declare function P(options: P.LoggerOptions, stream: stream.Writable | stream.Duplex | stream.Transform): P.Logger;
 
-    type Level = 'fatal' | 'error' | 'warn' | 'info' | 'debug' | 'trace' | 'silent'
-    type Headers = {[header: string]: string}
-    type LevelLabelsToValues = {[level: string]: number}
-    type LevelValuesToLabels = {[level: number]: string}
+declare namespace P {
+
+    function pretty(opts?: {timeTransOnly?: boolean, levelFirst?: boolean, formatter?: (str: string) => void}): stream.Transform;
+
+    type Level = 'fatal' | 'error' | 'warn' | 'info' | 'debug' | 'trace' | 'silent';
+    interface Headers {
+        [header: string]: string;
+    }
+
+    interface LevelLabelsToValues {
+        [level: string]: number;
+    }
+
+    interface LevelValuesToLabels {
+        [level: number]: string;
+    }
 
     interface Serializers {
-        req?: (req: any) => any
-        res?: (res: any) => any
-        err?: (error: Error) => any
+        req?: (req: any) => any;
+        res?: (res: any) => any;
+        err?: (error: Error) => any;
     }
 
     interface LoggerOptions {
         // avoid error causes by circular references in the object tree, default true
-        safe?: boolean
+        safe?: boolean;
         // the name of the logger, default undefined
-        name?: string
+        name?: string;
         // an object containing functions for custom serialization of objects.
         // These functions should return an JSONifiable object and they should never throw
-        serializers?: Serializers
+        serializers?: Serializers;
         // Outputs ISO time stamps ('2016-03-09T15:18:53.889Z') instead of Epoch time stamps (1457536759176).
         // WARNING: This option carries a 25% performance drop, we recommend using default Epoch timestamps and transforming logs after if required.
         // The pino -t command will do this for you (see CLI). default false.
-        slowtime?: boolean
+        slowtime?: boolean;
         // Enables extreme mode, yields an additional 60% performance (from 250ms down to 100ms per 10000 ops).
         // There are trade-off's should be understood before usage. See Extreme mode explained. default false
-        extreme?: boolean
+        extreme?: boolean;
         // enables logging, defaults to true.
-        enabled?: boolean
-        level?: Level
+        enabled?: boolean;
+        level?: Level;
     }
 
     interface Pino {
-        (optionsOrStream?: LoggerOptions | stream.Writable | stream.Readable): Logger
-        (options: LoggerOptions, stream: stream.Writable | stream.Readable): Logger
+        (optionsOrStream?: LoggerOptions | stream.Writable | stream.Duplex): Logger;
+        (options: LoggerOptions, stream: stream.Writable | stream.Duplex): Logger;
         levels: {
             values: LevelLabelsToValues
             labels: LevelValuesToLabels
-        }
-        LOG_VERSION: number
-        pretty(opts?: {timeTransOnly?: boolean}): stream.Readable
-
+        };
+        LOG_VERSION: number;
     }
 
-    type LevelChangeEventListener = (lvl: string, val: number, prevLvl: string, prevVal: number) => void
-    type LevelChangeEvent = 'level-change'
+    type LevelChangeEventListener = (lvl: string, val: number, prevLvl: string, prevVal: number) => void;
+    type LevelChangeEvent = 'level-change';
 
     interface Logger {
-        child(bindings: {}): Logger
-        level: Level
-        levelVal: number
-        on(event: LevelChangeEvent, listener: LevelChangeEventListener): void
-        fatal(msg: string, ...args : any[]): void
-        fatal(obj: {}, msg?: string, ...args : any[]): void
-        error(msg: string, ...args : any[]): void
-        error(obj: {}, msg?: string, ...args : any[]): void
-        warn(msg: string, ...args : any[]): void
-        warn(obj: {}, msg?: string, ...args : any[]): void
-        info(msg: string, ...args : any[]): void
-        info(obj: {}, msg?: string, ...args : any[]): void
-        debug(msg: string, ...args : any[]): void
-        debug(obj: {}, msg?: string, ...args : any[]): void
-        trace(msg: string, ...args : any[]): void
-        trace(obj: {}, msg?: string, ...args : any[]): void
+        child(bindings: {}): Logger;
+        level: Level;
+        levelVal: number;
+        on(event: LevelChangeEvent, listener: LevelChangeEventListener): void;
+        fatal(msg: string, ...args: any[]): void;
+        fatal(obj: {}, msg?: string, ...args: any[]): void;
+        error(msg: string, ...args: any[]): void;
+        error(obj: {}, msg?: string, ...args: any[]): void;
+        warn(msg: string, ...args: any[]): void;
+        warn(obj: {}, msg?: string, ...args: any[]): void;
+        info(msg: string, ...args: any[]): void;
+        info(obj: {}, msg?: string, ...args: any[]): void;
+        debug(msg: string, ...args: any[]): void;
+        debug(obj: {}, msg?: string, ...args: any[]): void;
+        trace(msg: string, ...args: any[]): void;
+        trace(obj: {}, msg?: string, ...args: any[]): void;
         levels: {
             values: LevelLabelsToValues
             labels: LevelValuesToLabels
-        }
-        LOG_VERSION: number
-        stdSerializers: Serializers
+        };
+        LOG_VERSION: number;
+        stdSerializers: Serializers;
     }
-
-    var p: Pino
-    export = p
-
 }
+
+export = P;

pino/pino-tests.ts

@@ -1,6 +1,8 @@
 // This contains all of the code from the docs on https://www.npmjs.com/package/pino
 
-import PINO = require('pino')
+import PINO = require('pino');
+import * as stream from 'stream';
+
 var pino = PINO()
 var info = pino.info
 var error = pino.error
@@ -14,8 +16,7 @@ info({ obj: { aa: 'bbb' } }, 'another')
 setImmediate(info, 'after setImmediate')
 error(new Error('an error'))
 
-
-var instance = PINO({
+let instance:PINO.Logger = PINO({
   name: 'myapp',
   safe: true,
   serializers: {
@@ -24,8 +25,12 @@ var instance = PINO({
   }
 })
 
-var pretty = PINO.pretty()
-var instance2 = PINO({
+let version:number = pino.LOG_VERSION
+let levels:Object = pino.levels
+
+let pretty:stream.Transform = PINO.pretty()
+
+let logger2:PINO.Logger = PINO({
   name: 'app',
   safe: true
 }, pretty)