feat(logger.ts): create a logger for uniform log messages

src/__tests__/logger.spec.ts

@@ -0,0 +1,52 @@
+import * as logger from '../logger';
+
+describe('logger', () => {
+  beforeEach(() => {
+    process.env.SILENT = '';
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('should print an info message', () => {
+    const spy = jest.spyOn(global.console, 'log').mockImplementation();
+
+    logger.info('Some message');
+    expect(spy).toHaveBeenCalledWith('⚡️[server INFO]: Some message');
+  });
+
+  it('should print a warn message', () => {
+    const spy = jest.spyOn(global.console, 'warn').mockImplementation();
+
+    logger.warn('Some message');
+    expect(spy).toHaveBeenCalledWith('⚡️[server WARN]: Some message');
+  });
+
+  it('should print an error message', () => {
+    const spy = jest.spyOn(global.console, 'error').mockImplementation();
+
+    logger.error('Some message');
+    expect(spy).toHaveBeenCalledWith('⚡️[server ERROR]: Some message');
+  });
+
+  it('should print a trace message', () => {
+    const spy = jest.spyOn(global.console, 'trace').mockImplementation();
+
+    logger.trace('Some message');
+    expect(spy).toHaveBeenCalledWith('⚡️[server ERROR]: Some message');
+  });
+
+  it.each([
+    ['log', logger.info],
+    ['warn', logger.warn],
+    ['error', logger.error],
+    ['trace', logger.trace]
+  ])('should not %s if SILENT env variable is set', (method: string, fn: () => void) => {
+    const spy = jest.spyOn(global.console, method as 'log' | 'warn' | 'error' | 'trace');
+
+    process.env.SILENT = 'true';
+    fn();
+    expect(spy).not.toHaveBeenCalled();
+  });
+});

src/logger.ts

@@ -0,0 +1,66 @@
+export enum Level {
+  INFO,
+  WARN,
+  ERROR
+}
+
+abstract class Logger {
+  private level: Level;
+  constructor(level: Level) {
+    this.level = level;
+  }
+
+  protected abstract logMethod(message: string): void;
+
+  log(...data: unknown[]): void {
+    if (process.env.SILENT) return;
+
+    const message = `⚡️[server ${Level[this.level]}]: ${data}`;
+    this.logMethod(message);
+  }
+}
+
+class InfoLogger extends Logger {
+  constructor() {
+    super(Level.INFO);
+  }
+
+  logMethod(message: string): void {
+    console.log(message);
+  }
+}
+
+class WarnLogger extends Logger {
+  constructor() {
+    super(Level.WARN);
+  }
+
+  protected logMethod(message: string): void {
+    console.warn(message);
+  }
+}
+
+class ErrorLogger extends Logger {
+  constructor() {
+    super(Level.ERROR);
+  }
+
+  protected logMethod(message: string): void {
+    console.error(message);
+  }
+}
+
+class TraceLogger extends Logger {
+  constructor() {
+    super(Level.ERROR);
+  }
+
+  protected logMethod(message: string): void {
+    console.trace(message);
+  }
+}
+
+export const info = (...data: unknown[]): void => new InfoLogger().log(data);
+export const warn = (...data: unknown[]): void => new WarnLogger().log(data);
+export const error = (...data: unknown[]): void => new ErrorLogger().log(data);
+export const trace = (...data: unknown[]): void => new TraceLogger().log(data);