@holz/core 0.2.0 → 0.5.0

package/dist/holz-core.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});var s=(e=>(e.Error="error",e.Warn="warn",e.Info="info",e.Debug="debug",e))(s||{});class t{constructor(r,o){this.processor=r,this.origin=o,Object.defineProperty(this,"processor",{configurable:!1,enumerable:!1})}static create(r){return new t(r,[])}namespace(r){return new t(this.processor,this.origin.concat(r))}debug(r,o){this.forwardLog(s.Debug,r,o)}info(r,o){this.forwardLog(s.Info,r,o)}warn(r,o){this.forwardLog(s.Warn,r,o)}error(r,o){this.forwardLog(s.Error,r,o)}forwardLog(r,o,i={}){this.processor.processLog({message:o,level:r,origin:this.origin,context:i})}}const c=t.create;class n{constructor(r){this.processors=r}processLog(r){this.processors.forEach(o=>{o.processLog(r)})}}function a(e){return new n(e)}class g{constructor(r,o){this.predicate=r,this.processor=o}processLog(r){this.predicate(r)&&this.processor.processLog(r)}}function f(e,r){return new g(e,r)}exports.LogLevel=s;exports.combine=a;exports.createLogger=c;exports.filter=f;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});var t=(o=>(o.Error="error",o.Warn="warn",o.Info="info",o.Debug="debug",o))(t||{});function i(o){return r=>o.forEach(e=>e(r))}function a(o,r){return e=>{o(e)&&r(e)}}class n{constructor(r,e){this.processor=r,this.owner=e,Object.defineProperty(this,"processor",{configurable:!1,enumerable:!1})}static create(r){return new n(r,[])}namespace(r){return new n(this.processor,this.owner.concat(r))}debug(r,e){this.forwardLog(t.Debug,r,e)}info(r,e){this.forwardLog(t.Info,r,e)}warn(r,e){this.forwardLog(t.Warn,r,e)}error(r,e){this.forwardLog(t.Error,r,e)}forwardLog(r,e,s={}){this.processor({message:e,level:r,origin:this.owner,context:s})}}const c=n.create;exports.LogLevel=t;exports.combine=i;exports.createLogger=c;exports.filter=a;

package/dist/holz-core.js

@@ -1,7 +1,15 @@
-var e = /* @__PURE__ */ ((s) => (s.Error = "error", s.Warn = "warn", s.Info = "info", s.Debug = "debug", s))(e || {});
+var n = /* @__PURE__ */ ((e) => (e.Error = "error", e.Warn = "warn", e.Info = "info", e.Debug = "debug", e))(n || {});
+function a(e) {
+  return (r) => e.forEach((o) => o(r));
+}
+function i(e, r) {
+  return (o) => {
+    e(o) && r(o);
+  };
+}
 class t {
   constructor(r, o) {
-    this.processor = r, this.origin = o, Object.defineProperty(this, "processor", {
+    this.processor = r, this.owner = o, Object.defineProperty(this, "processor", {
       configurable: !1,
       enumerable: !1
     });
@@ -17,61 +25,37 @@ class t {
   }
   /** Extend the logger to attach a class or module name to logs. */
   namespace(r) {
-    return new t(this.processor, this.origin.concat(r));
+    return new t(this.processor, this.owner.concat(r));
   }
   /** Log a frequent and verbose progress update. */
   debug(r, o) {
-    this.forwardLog(e.Debug, r, o);
+    this.forwardLog(n.Debug, r, o);
   }
   /** Log a high-level progress update. */
   info(r, o) {
-    this.forwardLog(e.Info, r, o);
+    this.forwardLog(n.Info, r, o);
   }
   /** Log something concerning. */
   warn(r, o) {
-    this.forwardLog(e.Warn, r, o);
+    this.forwardLog(n.Warn, r, o);
   }
   /** Log a critical failure. */
   error(r, o) {
-    this.forwardLog(e.Error, r, o);
+    this.forwardLog(n.Error, r, o);
   }
-  forwardLog(r, o, c = {}) {
-    this.processor.processLog({
+  forwardLog(r, o, s = {}) {
+    this.processor({
       message: o,
       level: r,
-      origin: this.origin,
-      context: c
-    });
-  }
-}
-const a = t.create;
-class i {
-  constructor(r) {
-    this.processors = r;
-  }
-  processLog(r) {
-    this.processors.forEach((o) => {
-      o.processLog(r);
+      origin: this.owner,
+      context: s
     });
   }
 }
-function f(s) {
-  return new i(s);
-}
-class n {
-  constructor(r, o) {
-    this.predicate = r, this.processor = o;
-  }
-  processLog(r) {
-    this.predicate(r) && this.processor.processLog(r);
-  }
-}
-function h(s, r) {
-  return new n(s, r);
-}
+const c = t.create;
 export {
-  e as LogLevel,
-  f as combine,
-  a as createLogger,
-  h as filter
+  n as LogLevel,
+  a as combine,
+  c as createLogger,
+  i as filter
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holz/core",
-  "version": "0.2.0",
+  "version": "0.5.0",
   "description": "A structured and composable logger",
   "type": "module",
   "main": "./dist/holz-core.cjs",
@@ -38,8 +38,8 @@
     "test:types": "tsc"
   },
   "devDependencies": {
-    "@vitest/coverage-c8": "0.28.5",
-    "typescript": "4.9.5",
+    "@vitest/coverage-c8": "^0.28.5",
+    "typescript": "^4.9.5",
     "vite": "^4.0.0",
     "vitest": "^0.28.5"
   }

package/src/__tests__/logger.test.ts

@@ -1,16 +1,15 @@
-import TestBackend from '../backends/test';
 import { createLogger } from '../logger';
 import { LogLevel } from '../types';
 
 describe('Logger', () => {
   it('sends structured logs to the log processor', () => {
-    const backend = new TestBackend();
+    const backend = vi.fn();
     const logger = createLogger(backend);
 
     logger.info('Hello world', { audience: 'testers' });
 
-    expect(backend.processLog).toHaveBeenCalledOnce();
-    expect(backend.processLog).toHaveBeenCalledWith({
+    expect(backend).toHaveBeenCalledOnce();
+    expect(backend).toHaveBeenCalledWith({
       message: 'Hello world',
       level: 'info',
       origin: [],
@@ -24,11 +23,11 @@ describe('Logger', () => {
     [LogLevel.Warn, 'There are irregularities in the pension fund', {}],
     [LogLevel.Error, 'Leadership has taken a dive', { windows: 'open' }],
   ])('correctly processes %s log messages', (level, message, context) => {
-    const backend = new TestBackend();
+    const backend = vi.fn();
     const logger = createLogger(backend);
 
     logger[level](message, context);
-    expect(backend.processLog).toHaveBeenCalledWith({
+    expect(backend).toHaveBeenCalledWith({
       message,
       level,
       context,
@@ -38,15 +37,15 @@ describe('Logger', () => {
 
   describe('namespace', () => {
     it('extends the origin of the logger', () => {
-      const backend = new TestBackend();
+      const backend = vi.fn();
       const logger = createLogger(backend)
         .namespace('signaling')
         .namespace('socket');
 
       logger.info('opening socket');
 
-      expect(backend.processLog).toHaveBeenCalledOnce();
-      expect(backend.processLog).toHaveBeenCalledWith({
+      expect(backend).toHaveBeenCalledOnce();
+      expect(backend).toHaveBeenCalledWith({
         message: 'opening socket',
         level: 'info',
         origin: ['signaling', 'socket'],

package/src/__tests__/operators.test.ts

@@ -0,0 +1,48 @@
+import { createLogger } from '../logger';
+import { combine, filter } from '../operators';
+import { LogLevel } from '../types';
+
+describe('operators', () => {
+  describe('combine', () => {
+    it('combines several log processors backends into one', () => {
+      const b1 = vi.fn();
+      const b2 = vi.fn();
+      const backend = combine([b1, b2]);
+      const logger = createLogger(backend);
+
+      logger.info('tee message');
+
+      expect(b1).toHaveBeenCalledWith(
+        expect.objectContaining({ message: 'tee message' })
+      );
+
+      expect(b2).toHaveBeenCalledWith(
+        expect.objectContaining({ message: 'tee message' })
+      );
+    });
+
+    it('works even if you provide no logging backend', () => {
+      const backend = combine([]);
+      const logger = createLogger(backend);
+
+      expect(() => logger.info('no backend')).not.toThrow();
+    });
+  });
+
+  describe('filter', () => {
+    it('filters out logs that do not match the predicate', () => {
+      const backend = vi.fn();
+      const logger = createLogger(
+        filter((log) => log.level !== LogLevel.Debug, backend)
+      );
+
+      logger.info('keep me');
+      logger.debug('discard');
+
+      expect(backend).toHaveBeenCalledOnce();
+      expect(backend).toHaveBeenCalledWith(
+        expect.objectContaining({ message: 'keep me' })
+      );
+    });
+  });
+});

package/src/index.ts

@@ -1,5 +1,4 @@
 export type { LogProcessor, LogContext, Log } from './types';
 export { LogLevel } from './types';
+export { combine, filter } from './operators';
 export { createLogger } from './logger';
-export { default as combine } from './operators/combine';
-export { default as filter } from './operators/filter';

package/src/logger.ts

@@ -14,7 +14,7 @@ class Logger {
 
   private constructor(
     private processor: LogProcessor,
-    readonly origin: ReadonlyArray<string>
+    readonly owner: ReadonlyArray<string>
   ) {
     // Non-enumerable to keep the repls clean.
     Object.defineProperty(this, 'processor', {
@@ -25,7 +25,7 @@ class Logger {
 
   /** Extend the logger to attach a class or module name to logs. */
   namespace(owner: string): Logger {
-    return new Logger(this.processor, this.origin.concat(owner));
+    return new Logger(this.processor, this.owner.concat(owner));
   }
 
   /** Log a frequent and verbose progress update. */
@@ -53,10 +53,10 @@ class Logger {
     message: string,
     context: LogContext = {}
   ) {
-    this.processor.processLog({
+    this.processor({
       message,
       level,
-      origin: this.origin,
+      origin: this.owner,
       context,
     });
   }

package/src/operators.ts

@@ -0,0 +1,28 @@
+import type { Log, LogProcessor } from './types';
+
+/**
+ * Combine several log processors into a single log processor. Each one is
+ * called in sequence. Useful for sending a single log to multiple log
+ * destinations.
+ */
+export function combine(processors: Array<LogProcessor>): LogProcessor {
+  return (log: Log) => processors.forEach((processor) => processor(log));
+}
+
+/**
+ * Filter logs based on a filter function. If the function returns true, the
+ * log is kept and forwarded onto the next processor, otherwise it is
+ * discarded.
+ */
+export function filter(
+  /** Returns `true` to forward the log. */
+  predicate: (log: Log) => boolean,
+  /** Where to send the log if it passes the filter. */
+  processor: LogProcessor
+): LogProcessor {
+  return (log: Log) => {
+    if (predicate(log)) {
+      processor(log);
+    }
+  };
+}

package/src/types.ts

@@ -5,7 +5,7 @@
  */
 export interface LogProcessor {
   /** Do something with a log message. */
-  processLog(log: Log): void;
+  (log: Log): void;
 }
 
 /** A log message where variables are carried as structured data. */

package/src/backends/test.ts

@@ -1,5 +0,0 @@
-import type { LogProcessor } from '../types';
-
-export default class TestBackend implements LogProcessor {
-  processLog = vi.fn();
-}

package/src/operators/__tests__/combine.test.ts

@@ -1,29 +0,0 @@
-import TestBackend from '../../backends/test';
-import { createLogger } from '../../logger';
-import combine from '../combine';
-
-describe('combine operator', () => {
-  it('combines several log processors backends into one', () => {
-    const b1 = new TestBackend();
-    const b2 = new TestBackend();
-    const backend = combine([b1, b2]);
-    const logger = createLogger(backend);
-
-    logger.info('tee message');
-
-    expect(b1.processLog).toHaveBeenCalledWith(
-      expect.objectContaining({ message: 'tee message' })
-    );
-
-    expect(b2.processLog).toHaveBeenCalledWith(
-      expect.objectContaining({ message: 'tee message' })
-    );
-  });
-
-  it('works even if you provide no logging backend', () => {
-    const backend = combine([]);
-    const logger = createLogger(backend);
-
-    expect(() => logger.info('no backend')).not.toThrow();
-  });
-});

package/src/operators/__tests__/filter.test.ts

@@ -1,21 +0,0 @@
-import TestBackend from '../../backends/test';
-import { createLogger } from '../../logger';
-import { LogLevel } from '../../types';
-import filter from '../filter';
-
-describe('filter operator', () => {
-  it('filters out logs that do not match the predicate', () => {
-    const backend = new TestBackend();
-    const logger = createLogger(
-      filter((log) => log.level !== LogLevel.Debug, backend)
-    );
-
-    logger.info('keep me');
-    logger.debug('discard');
-
-    expect(backend.processLog).toHaveBeenCalledOnce();
-    expect(backend.processLog).toHaveBeenCalledWith(
-      expect.objectContaining({ message: 'keep me' })
-    );
-  });
-});

package/src/operators/combine.ts

@@ -1,22 +0,0 @@
-import type { Log, LogProcessor } from '../types';
-
-class CombinedLogProcessor implements LogProcessor {
-  constructor(private processors: Array<LogProcessor>) {
-    // empty
-  }
-
-  processLog(log: Log) {
-    this.processors.forEach((processor) => {
-      processor.processLog(log);
-    });
-  }
-}
-
-/**
- * Combine several log processors into a single log processor. Each one is
- * called in sequence. Useful for sending a single log to multiple log
- * destinations.
- */
-export default function combine(processors: Array<LogProcessor>): LogProcessor {
-  return new CombinedLogProcessor(processors);
-}

package/src/operators/filter.ts

@@ -1,28 +0,0 @@
-import type { Log, LogProcessor } from '../types';
-
-class LogFilter implements LogProcessor {
-  constructor(
-    private predicate: (log: Log) => boolean,
-    private processor: LogProcessor
-  ) {}
-
-  processLog(log: Log) {
-    if (this.predicate(log)) {
-      this.processor.processLog(log);
-    }
-  }
-}
-
-/**
- * Filter logs based on a filter function. If the function returns true, the
- * log is kept and forwarded onto the next processor, otherwise it is
- * discarded.
- */
-export default function filter(
-  /** Returns `true` to forward the log. */
-  predicate: (log: Log) => boolean,
-  /** Where to send the log if it passes the filter. */
-  processor: LogProcessor
-): LogProcessor {
-  return new LogFilter(predicate, processor);
-}