feat(common): add log filtering function

packages/common/services/logger.service.ts

@@ -3,10 +3,51 @@ import { isObject } from '../utils/shared.utils';
 import { ConsoleLogger } from './console-logger.service';
 import { isLogLevelEnabled } from './utils';
 
+const LOG_LEVELS = [
+  'verbose',
+  'debug',
+  'log',
+  'warn',
+  'error',
+  'fatal',
+] as const satisfies string[];
+
+/**
+ * @publicApi
+ */
+export type LogLevel = (typeof LOG_LEVELS)[number];
+
+/**
+ * @publicApi
+ */
+export function isLogLevel(maybeLogLevel: any): maybeLogLevel is LogLevel {
+  return LOG_LEVELS.includes(maybeLogLevel);
+}
+
 /**
  * @publicApi
  */
-export type LogLevel = 'log' | 'error' | 'warn' | 'debug' | 'verbose' | 'fatal';
+export function filterLogLevels(parseableString = ''): LogLevel[] {
+  const sanitizedSring = parseableString.replaceAll(' ', '').toLowerCase();
+
+  if (sanitizedSring[0] === '>') {
+    const orEqual = sanitizedSring[1] === '=';
+
+    const logLevelIndex = (LOG_LEVELS as string[]).indexOf(
+      sanitizedSring.substring(orEqual ? 2 : 1),
+    );
+
+    if (logLevelIndex === -1) {
+      throw new Error(`parse error (unknown log level): ${sanitizedSring}`);
+    }
+
+    return LOG_LEVELS.slice(orEqual ? logLevelIndex : logLevelIndex + 1);
+  } else if (sanitizedSring.includes(',')) {
+    return sanitizedSring.split(',').filter(isLogLevel);
+  }
+
+  return isLogLevel(sanitizedSring) ? [sanitizedSring] : LOG_LEVELS;
+}
 
 /**
  * @publicApi

packages/common/test/services/logger.service.spec.ts

@@ -1,9 +1,51 @@
 import { expect } from 'chai';
 import 'reflect-metadata';
 import * as sinon from 'sinon';
-import { ConsoleLogger, Logger, LoggerService, LogLevel } from '../../services';
+import {
+  ConsoleLogger,
+  filterLogLevels,
+  Logger,
+  LoggerService,
+  LogLevel,
+} from '../../services';
 
 describe('Logger', () => {
+  describe('[log helpers]', () => {
+    describe('when using filterLogLevels', () => {
+      it('should correctly parse an exclusive range', () => {
+        const returned = filterLogLevels('>warn');
+        expect(returned).to.deep.equal(['error', 'fatal']);
+      });
+
+      it('should correctly parse an inclusive range', () => {
+        const returned = filterLogLevels('>=warn');
+        expect(returned).to.deep.equal(['warn', 'error', 'fatal']);
+      });
+
+      it('should correctly parse a string list', () => {
+        const returned = filterLogLevels('verbose,warn,fatal');
+        expect(returned).to.deep.equal(['verbose', 'warn', 'fatal']);
+      });
+
+      it('should correctly parse a single log level', () => {
+        const returned = filterLogLevels('debug');
+        expect(returned).to.deep.equal(['debug']);
+      });
+
+      it('should return all otherwise', () => {
+        const returned = filterLogLevels();
+        expect(returned).to.deep.equal([
+          'verbose',
+          'debug',
+          'log',
+          'warn',
+          'error',
+          'fatal',
+        ]);
+      });
+    });
+  });
+
   describe('[static methods]', () => {
     describe('when the default logger is used', () => {
       let processStdoutWriteSpy: sinon.SinonSpy;