♻️ Rename interfaces

Author: Michal Vlasák

CHANGELOG.md

@@ -6,6 +6,7 @@
 
 ### Changed
 - `pino.pretty` replaced with `util.inspect`
+- rename interfaces
 
 ## [1.1.0] - 2019-08-05
 

src/express.ts

@@ -1,19 +1,14 @@
 import { ErrorRequestHandler, Request, RequestHandler, Response } from 'express';
 import * as onFinished from 'on-finished';
 import onHeaders = require('on-headers');
-import { AckeeLogger } from '.';
+import { Cosmas } from '.';
 
 const errorSymbol = Symbol.for('error');
 
 type AckeeRequest = Request & { _startAt?: [number, number]; ackId?: string };
 type AckeeResponse = Response & { _startAt?: [number, number]; time?: string; out?: object; [errorSymbol]?: any };
 
-export type AckeeLoggerExpressMiddleware = (
-    this: AckeeLogger,
-    req: AckeeRequest,
-    response: AckeeResponse,
-    next: any
-) => void;
+export type CosmasExpressMiddleware = (this: Cosmas, req: AckeeRequest, response: AckeeResponse, next: any) => void;
 
 const expressOnHeaders = (req: AckeeRequest, res: AckeeResponse) => () => {
     res._startAt = process.hrtime();
@@ -23,11 +18,11 @@ const expressOnHeaders = (req: AckeeRequest, res: AckeeResponse) => () => {
     res.time = ms.toFixed(3);
 };
 
-const shouldSkipLogging = (logger: AckeeLogger, req: AckeeRequest, res?: AckeeResponse) =>
+const shouldSkipLogging = (logger: Cosmas, req: AckeeRequest, res?: AckeeResponse) =>
     (logger.options.skip && logger.options.skip(req, res)) ||
     (logger.options.ignoredHttpMethods && logger.options.ignoredHttpMethods.includes(req.method));
 
-const expressOnFinished = (logger: AckeeLogger, req: AckeeRequest) => (_err: Error | null, res: AckeeResponse) => {
+const expressOnFinished = (logger: Cosmas, req: AckeeRequest) => (_err: Error | null, res: AckeeResponse) => {
     if (shouldSkipLogging(logger, req, res)) {
         return;
     }
@@ -55,7 +50,7 @@ const expressOnFinished = (logger: AckeeLogger, req: AckeeRequest) => (_err: Err
 };
 
 const expressMiddleware: RequestHandler = function(
-    this: AckeeLogger,
+    this: Cosmas,
     req: AckeeRequest,
     response: AckeeResponse,
     next: any

src/index.ts

@@ -4,25 +4,25 @@ import isString = require('lodash.isstring');
 import * as pino from 'pino';
 import * as pinoms from 'pino-multi-stream';
 import { Writable } from 'stream';
-import { AckeeLoggerExpressMiddleware, expressErrorMiddleware, expressMiddleware } from './express';
-import { AckeeLoggerOptions } from './interfaces';
+import { CosmasExpressMiddleware, expressErrorMiddleware, expressMiddleware } from './express';
+import { CosmasOptions } from './interfaces';
 import * as serializers from './serializers';
 import { initLoggerStreams } from './streams';
 
 export type PinoLogger = pino.BaseLogger;
 export type Level = pino.LevelWithSilent;
 
-export interface AckeeLogger extends PinoLogger {
+export interface Cosmas extends PinoLogger {
     warning: pino.LogFn;
-    options: AckeeLoggerOptions;
-    express: AckeeLoggerExpressMiddleware;
+    options: CosmasOptions;
+    express: CosmasExpressMiddleware;
     expressError: ErrorRequestHandler;
     stream: Writable;
     (childName: string): any;
 }
 
-export interface AckeeLoggerFactory extends AckeeLogger {
-    (data?: string | AckeeLoggerOptions): AckeeLogger;
+export interface CosmasFactory extends Cosmas {
+    (data?: string | CosmasOptions): Cosmas;
 }
 
 // cannot use Symbols, because they aren't JSON.stringifyable
@@ -65,7 +65,7 @@ const maxLevelWrite: pino.WriteFn = function(this: any, data: object): void {
     }
 };
 
-const defaultLogger = (options: AckeeLoggerOptions & { loggerName?: string } = {}): AckeeLogger => {
+const defaultLogger = (options: CosmasOptions & { loggerName?: string } = {}): Cosmas => {
     serializers.disablePaths(options.disableFields);
     serializers.enablePaths(options.enableFields);
 
@@ -96,7 +96,7 @@ const defaultLogger = (options: AckeeLoggerOptions & { loggerName?: string } = {
             options.config
         ),
         (pinoms as any).multistream(streams)
-    ) as PinoLogger) as AckeeLogger;
+    ) as PinoLogger) as Cosmas;
 
     // Add maxLevel support to pino-multi-stream
     // This could be replaced with custom pass-through stream being passed to multistream, which would filter the messages
@@ -114,9 +114,9 @@ const defaultLogger = (options: AckeeLoggerOptions & { loggerName?: string } = {
     });
 };
 
-const parseLoggerData = (data: string | AckeeLoggerOptions = {}) => {
+const parseLoggerData = (data: string | CosmasOptions = {}) => {
     let loggerName: string | undefined;
-    let options: AckeeLoggerOptions = {};
+    let options: CosmasOptions = {};
     if (data) {
         if (isString(data)) {
             loggerName = data;
@@ -129,7 +129,7 @@ const parseLoggerData = (data: string | AckeeLoggerOptions = {}) => {
     return { loggerName, options };
 };
 
-const loggerFactory = (data: string | AckeeLoggerOptions = {}, loggerOptions: AckeeLoggerOptions = {}): AckeeLogger => {
+const loggerFactory = (data: string | CosmasOptions = {}, loggerOptions: CosmasOptions = {}): Cosmas => {
     const { loggerName, options } = parseLoggerData(data);
     loggerOptions = objEmpty(options) ? loggerOptions : options;
     const logger = defaultLogger(Object.assign({ loggerName }, loggerOptions));

src/interfaces.ts

@@ -6,18 +6,18 @@ interface LoggerOptions extends pino.LoggerOptions {
 }
 
 // this is basically enhanced version of pino-multi-stream.Streams type
-export interface AckeeLoggerStream {
+export interface CosmasStream {
     level?: pino.LevelWithSilent;
     maxLevel?: number; // this is not processed by pino, so we need the number directly
     stream: NodeJS.WritableStream;
 }
 
-export interface AckeeLoggerOptions {
+export interface CosmasOptions {
     disableFields?: string[];
     enableFields?: string[];
     defaultLevel?: pino.LevelWithSilent;
     disableStackdriverFormat?: boolean;
-    streams?: AckeeLoggerStream[];
+    streams?: CosmasStream[];
     ignoredHttpMethods?: string[];
     config?: LoggerOptions;
     pretty?: boolean;

src/streams.ts

@@ -4,14 +4,14 @@ import * as pino from 'pino';
 import { Transform, TransformCallback } from 'stream';
 import * as util from 'util';
 import { loggerNameKey, pkgVersionKey } from '.';
-import { AckeeLoggerOptions, AckeeLoggerStream } from './interfaces';
+import { CosmasOptions, CosmasStream } from './interfaces';
 import { levels } from './levels';
 import { SentryTransformStream } from './sentry';
 import { StackDriverFormatStream } from './stackdriver';
 
 const pkgJson = JSON.parse(fs.readFileSync(path.resolve(path.join(__dirname, '..', 'package.json')), 'utf8'));
 
-const getDefaultTransformStream = (options: AckeeLoggerOptions & { messageKey: string; loggerName?: string }) => {
+const getDefaultTransformStream = (options: CosmasOptions & { messageKey: string; loggerName?: string }) => {
     class DefaultTransformStream extends Transform {
         // tslint:disable-next-line:function-name
         public _transform(chunk: any, _encoding: string, callback: TransformCallback) {
@@ -42,7 +42,7 @@ const getDefaultTransformStream = (options: AckeeLoggerOptions & { messageKey: s
     return DefaultTransformStream;
 };
 
-const decorateStreams = <T extends Transform>(streams: AckeeLoggerStream[], streamClass: new () => T) => {
+const decorateStreams = <T extends Transform>(streams: CosmasStream[], streamClass: new () => T) => {
     return streams.map(stream => {
         const newStream = new streamClass();
         newStream.pipe(stream.stream);
@@ -56,9 +56,9 @@ const decorateStreams = <T extends Transform>(streams: AckeeLoggerStream[], stre
 
 const initLoggerStreams = (
     defaultLevel: pino.LevelWithSilent,
-    options: AckeeLoggerOptions & { messageKey: string; loggerName?: string }
+    options: CosmasOptions & { messageKey: string; loggerName?: string }
 ) => {
-    let streams: AckeeLoggerStream[];
+    let streams: CosmasStream[];
     if (options.streams) {
         streams = options.streams.map(stream => Object.assign({ level: defaultLevel }, stream));
     } else {