@holz/pattern-filter 0.1.0

package/dist/holz-pattern-filter.js

@@ -0,0 +1,19 @@
+const o = (s) => s.split(/[\s,]+/).filter(Boolean).reduce(
+  (t, r) => (r[0] === "-" ? t.exclude.push(c(r.slice(1))) : t.include.push(c(r)), t),
+  { include: [], exclude: [] }
+), n = (s, e) => s.exclude.every((t) => !t.test(e)) && s.include.some((t) => t.test(e)), c = (s) => {
+  const e = s.replace(/\*/g, ".*?");
+  return new RegExp(`^${e}$`);
+};
+class i {
+  constructor(e) {
+    this.pattern = e.pattern, this.processor = e.processor, this.filters = o(e.pattern);
+  }
+  processLog(e) {
+    n(this.filters, e.origin.join(":")) && this.processor.processLog(e);
+  }
+}
+export {
+  i as PatternFilter,
+  i as default
+};

package/dist/holz-pattern-filter.umd.cjs

@@ -0,0 +1 @@
+(function(t,n){typeof exports=="object"&&typeof module<"u"?n(exports):typeof define=="function"&&define.amd?define(["exports"],n):(t=typeof globalThis<"u"?globalThis:t||self,n(t["holz-pattern-filter"]={}))})(this,function(t){"use strict";const n=s=>s.split(/[\s,]+/).filter(Boolean).reduce((r,i)=>(i[0]==="-"?r.exclude.push(o(i.slice(1))):r.include.push(o(i)),r),{include:[],exclude:[]}),l=(s,e)=>s.exclude.every(r=>!r.test(e))&&s.include.some(r=>r.test(e)),o=s=>{const e=s.replace(/\*/g,".*?");return new RegExp(`^${e}$`)};class c{constructor(e){this.pattern=e.pattern,this.processor=e.processor,this.filters=n(e.pattern)}processLog(e){l(this.filters,e.origin.join(":"))&&this.processor.processLog(e)}}t.PatternFilter=c,t.default=c,Object.defineProperties(t,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}})});

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@holz/pattern-filter",
+  "version": "0.1.0",
+  "description": "Only print log messages that match a pattern",
+  "type": "module",
+  "main": "./dist/holz-pattern-filter.umd.cjs",
+  "module": "./dist/holz-pattern-filter.js",
+  "types": "./src/index.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/PsychoLlama/holz",
+    "directory": "packages/holz-pattern-filter"
+  },
+  "exports": {
+    ".": {
+      "require": "./dist/holz-pattern-filter.umd.cjs",
+      "import": "./dist/holz-pattern-filter.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "Jesse Gibson",
+  "license": "MIT",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "src"
+  ],
+  "keywords": [
+    "holz",
+    "logger",
+    "filter",
+    "pattern",
+    "exclude"
+  ],
+  "scripts": {
+    "prepare": "vite build",
+    "test:unit": "vitest --color --passWithNoTests",
+    "test:types": "tsc"
+  },
+  "devDependencies": {
+    "@holz/core": "0.1.0",
+    "@vitest/coverage-c8": "0.28.5",
+    "typescript": "4.9.5",
+    "vite": "^4.0.0",
+    "vitest": "^0.28.5"
+  }
+}

package/src/__tests__/pattern-filter.test.ts

@@ -0,0 +1,42 @@
+import type { LogProcessor } from '@holz/core';
+import { createLogger } from '@holz/core';
+import PatternFilter from '../pattern-filter';
+
+class TestBackend implements LogProcessor {
+  processLog = vi.fn();
+}
+
+describe('PatternFilter', () => {
+  it('only passes through logs that have the filter', () => {
+    const backend = new TestBackend();
+    const filter = new PatternFilter({
+      pattern: '-ignored, -*:wild, *',
+      processor: backend,
+    });
+
+    const logger = createLogger(filter);
+
+    logger.namespace('ignored').info('excluded by filter');
+    expect(backend.processLog).not.toHaveBeenCalled();
+
+    logger.namespace('something').namespace('wild').info('also excluded');
+    expect(backend.processLog).not.toHaveBeenCalled();
+
+    logger.namespace('app').info('not ignored');
+    expect(backend.processLog).toHaveBeenCalledWith(
+      expect.objectContaining({
+        message: 'not ignored',
+      })
+    );
+  });
+
+  it('does not send anything by default', () => {
+    const backend = new TestBackend();
+    const filter = new PatternFilter({ pattern: '', processor: backend });
+    const logger = createLogger(filter);
+
+    logger.info('no include patterns mean this is ignored');
+
+    expect(backend.processLog).not.toHaveBeenCalled();
+  });
+});

package/src/__tests__/string-match.test.ts

@@ -0,0 +1,56 @@
+import { parse, matches } from '../string-match';
+
+describe('string-match', () => {
+  describe('parse', () => {
+    it('parses include patterns', () => {
+      expect(parse('  foo,bar baz  , qux  ')).toEqual({
+        include: [/^foo$/, /^bar$/, /^baz$/, /^qux$/],
+        exclude: [],
+      });
+    });
+
+    it('detects and groups exclusion patterns', () => {
+      expect(parse('first,-second,-third,fourth')).toEqual({
+        include: [/^first$/, /^fourth$/],
+        exclude: [/^second$/, /^third$/],
+      });
+    });
+
+    it('converts star patterns to regex wildcards', () => {
+      expect(parse('first,second*,split*part')).toEqual({
+        include: [/^first$/, /^second.*?$/, /^split.*?part$/],
+        exclude: [],
+      });
+    });
+  });
+
+  describe('matches', () => {
+    it('returns true if the pattern matches', () => {
+      expect(matches(parse('hello'), 'hello')).toBe(true);
+    });
+
+    it('returns true if the pattern matches a wildcard', () => {
+      expect(matches(parse('hello*'), 'hello world')).toBe(true);
+    });
+
+    it('returns false if the pattern does not match', () => {
+      expect(matches(parse('hello'), 'bar')).toBe(false);
+    });
+
+    it('returns false if the pattern is excluded', () => {
+      expect(matches(parse('-hello'), 'hello')).toBe(false);
+    });
+
+    it('returns true if the pattern is included', () => {
+      expect(matches(parse('hello'), 'hello')).toBe(true);
+    });
+
+    it('does not match if there is a contradiction', () => {
+      expect(matches(parse('maybe,-maybe'), 'maybe')).toBe(false);
+    });
+
+    it('does not match if the filter is empty', () => {
+      expect(matches(parse(''), 'content')).toBe(false);
+    });
+  });
+});

package/src/index.ts

@@ -0,0 +1 @@
+export { default, default as PatternFilter } from './pattern-filter';

package/src/pattern-filter.ts

@@ -0,0 +1,43 @@
+import type { Log, LogProcessor } from '@holz/core';
+import { parse, matches } from './string-match';
+
+/**
+ * Only forwards logs who's origin matches the given pattern. It works the
+ * same as the popular `debug` module.
+ *
+ * Patterns allow wildcards and negation. For example, the pattern `my-app*`
+ * will match all logs with the origin `my-app` or `my-app:foo` or
+ * `my-app:foo:bar`. The pattern `*, -my-app` will match all logs except those
+ * with the origin `my-app`.
+ *
+ * @example
+ * new PatternFilter({
+ *   pattern: 'my-app*, -spammy:library',
+ *   processor: backend,
+ * })
+ */
+export default class PatternFilter implements LogProcessor {
+  private filters: ReturnType<typeof parse>;
+  readonly pattern: string;
+  private processor: LogProcessor;
+
+  constructor(config: Config) {
+    this.pattern = config.pattern;
+    this.processor = config.processor;
+    this.filters = parse(config.pattern);
+  }
+
+  processLog(log: Log) {
+    if (matches(this.filters, log.origin.join(':'))) {
+      this.processor.processLog(log);
+    }
+  }
+}
+
+interface Config {
+  /** A set of patterns to test against `log.origin`. */
+  pattern: string;
+
+  /** Where to send logs if they pass the filter. */
+  processor: LogProcessor;
+}

package/src/string-match.ts

@@ -0,0 +1,42 @@
+/**
+ * Parse a string of multiple patterns into a set of regular expressions. We
+ * use a pattern string (instead of regexes) because it's easier to persist in
+ * storage or specify through a CLI.
+ *
+ * Special thanks to `debug-js` for the inspiration. I read their code as
+ * a guide for this implementation.
+ */
+export const parse = (input: string): PatternFilters => {
+  const patterns = input.split(/[\s,]+/).filter(Boolean);
+
+  return patterns.reduce<PatternFilters>(
+    (groups, pattern) => {
+      if (pattern[0] === '-') {
+        groups.exclude.push(toRegex(pattern.slice(1)));
+      } else {
+        groups.include.push(toRegex(pattern));
+      }
+
+      return groups;
+    },
+    { include: [], exclude: [] }
+  );
+};
+
+/** Detect if a string matches a set of patterns. */
+export const matches = (filters: PatternFilters, input: string): boolean => {
+  return (
+    filters.exclude.every((pattern) => !pattern.test(input)) &&
+    filters.include.some((pattern) => pattern.test(input))
+  );
+};
+
+const toRegex = (pattern: string): RegExp => {
+  const regex = pattern.replace(/\*/g, '.*?');
+  return new RegExp(`^${regex}$`);
+};
+
+interface PatternFilters {
+  include: Array<RegExp>;
+  exclude: Array<RegExp>;
+}