kayvee 3.16.0 → 3.18.0

package/test/router.ts

@@ -55,41 +55,61 @@ routes:
       stat_type: "gauge"
 `;
       const expected = [
-        new router.Rule("rule-one", {title: ["authorize-app"]}, {
-          type: "notifications",
-          channel: "%{foo.bar}",
-          icon: ":rocket:",
-          message: "authorized %{foo.bar} in Hogwarts",
-          user: "@fishman",
-        }),
-        new router.Rule("rule-two", {"foo.bar": ["multiple", "matches"], baz: ["whatever"]}, {
-          type: "alerts",
-          series: "other-series",
-          dimensions: ["baz"],
-          stat_type: "gauge",
-          value_field: "value",
-        }),
-        new router.Rule("rule-three", {"foo.bar": ["multiple", "matches"], baz: ["whatever"]}, {
-          type: "alerts",
-          series: "other-series",
-          dimensions: ["baz"],
-          stat_type: "gauge",
-          value_field: "hello",
-        }),
-        new router.Rule("rule-four", {"foo.bar": ["multiple", "matches"], baz: ["whatever"]}, {
-          type: "alerts",
-          series: "other-series",
-          dimensions: [],
-          stat_type: "gauge",
-          value_field: "value",
-        }),
-        new router.Rule("rule-five", {"foo.bar": [true], baz: [false]}, {
-          type: "alerts",
-          series: "other-series",
-          dimensions: [],
-          stat_type: "gauge",
-          value_field: "value",
-        }),
+        new router.Rule(
+          "rule-one",
+          { title: ["authorize-app"] },
+          {
+            type: "notifications",
+            channel: "%{foo.bar}",
+            icon: ":rocket:",
+            message: "authorized %{foo.bar} in Hogwarts",
+            user: "@fishman",
+          },
+        ),
+        new router.Rule(
+          "rule-two",
+          { "foo.bar": ["multiple", "matches"], baz: ["whatever"] },
+          {
+            type: "alerts",
+            series: "other-series",
+            dimensions: ["baz"],
+            stat_type: "gauge",
+            value_field: "value",
+          },
+        ),
+        new router.Rule(
+          "rule-three",
+          { "foo.bar": ["multiple", "matches"], baz: ["whatever"] },
+          {
+            type: "alerts",
+            series: "other-series",
+            dimensions: ["baz"],
+            stat_type: "gauge",
+            value_field: "hello",
+          },
+        ),
+        new router.Rule(
+          "rule-four",
+          { "foo.bar": ["multiple", "matches"], baz: ["whatever"] },
+          {
+            type: "alerts",
+            series: "other-series",
+            dimensions: [],
+            stat_type: "gauge",
+            value_field: "value",
+          },
+        ),
+        new router.Rule(
+          "rule-five",
+          { "foo.bar": [true], baz: [false] },
+          {
+            type: "alerts",
+            series: "other-series",
+            dimensions: [],
+            stat_type: "gauge",
+            value_field: "value",
+          },
+        ),
       ];
       const actual = new router.Router();
       actual._loadConfigString(conf);
@@ -108,7 +128,7 @@ routes:
 `;
 
       // Make sure the template works
-      const conf = confTmpl("\"valid\"");
+      const conf = confTmpl('"valid"');
       const actual = new router.Router();
       assert.doesNotThrow(() => actual._loadConfigString(conf));
 
@@ -116,11 +136,10 @@ routes:
         const invalidConf = confTmpl(invalidVal);
         assert.throws(() => actual._loadConfigString(invalidConf));
       }
-      assert.throws(() => actual._loadConfigString(confTmpl("\"\"")));
+      assert.throws(() => actual._loadConfigString(confTmpl('""')));
       return;
     });
 
-
     it("rejects duplicates in matchers", () => {
       const confTmpl = (v) => `
 routes:
@@ -133,10 +152,10 @@ routes:
 `;
 
       const actual = new router.Router();
-      const validConf = confTmpl("\"non-repeated\", \"name\"");
+      const validConf = confTmpl('"non-repeated", "name"');
       assert.doesNotThrow(() => actual._loadConfigString(validConf));
 
-      const invalidConf = confTmpl("\"repeated\", \"repeated\", \"name\"");
+      const invalidConf = confTmpl('"repeated", "repeated", "name"');
       assert.throws(() => actual._loadConfigString(invalidConf));
     });
 
@@ -155,13 +174,13 @@ routes:
 `;
 
       const actual = new router.Router();
-      const validConf = confTmpl("\"my-series\"", "[\"dim1\", \"dim2\"]");
+      const validConf = confTmpl('"my-series"', '["dim1", "dim2"]');
       assert.doesNotThrow(() => actual._loadConfigString(validConf));
 
-      const invalidConf0 = confTmpl("[\"my-series\"]", "[\"dim1\", \"dim2\"]");
+      const invalidConf0 = confTmpl('["my-series"]', '["dim1", "dim2"]');
       assert.throws(() => actual._loadConfigString(invalidConf0));
 
-      const invalidConf1 = confTmpl("\"my-series\"", "\"dim1\"");
+      const invalidConf1 = confTmpl('"my-series"', '"dim1"');
       assert.throws(() => actual._loadConfigString(invalidConf1));
     });
 
@@ -285,25 +304,23 @@ routes:
       const r = new router.Router([
         new router.Rule(
           "rule-one",
-          {title: ["hello", "hi"], foo: ["bar", "baz"]},
-          {channel: "#-%{foo}-", dimensions: ["-%{foo}-"]}
-        ),
-        new router.Rule(
-          "rule-two",
-          {"bing.bong": ["buzz"]},
-          {series: "x"}
+          { title: ["hello", "hi"], foo: ["bar", "baz"] },
+          { channel: "#-%{foo}-", dimensions: ["-%{foo}-"] },
         ),
+        new router.Rule("rule-two", { "bing.bong": ["buzz"] }, { series: "x" }),
       ]);
 
       const msg0 = {
         title: "hi",
-        foo:   "bar",
+        foo: "bar",
       };
-      const expected0 = [{
-        rule:       "rule-one",
-        channel:    "#-bar-",
-        dimensions: ["-bar-"],
-      }];
+      const expected0 = [
+        {
+          rule: "rule-one",
+          channel: "#-bar-",
+          dimensions: ["-bar-"],
+        },
+      ];
       const actual0 = r.route(msg0).routes;
       assert.deepEqual(expected0, actual0);
 
@@ -313,28 +330,30 @@ routes:
           bong: "buzz",
         },
       };
-      const expected1 = [{
-        rule:   "rule-two",
-        series: "x",
-      }];
+      const expected1 = [
+        {
+          rule: "rule-two",
+          series: "x",
+        },
+      ];
       const actual1 = r.route(msg1).routes;
       assert.deepEqual(expected1, actual1);
 
       const msg2 = {
         title: "hello",
-        foo:   "baz",
+        foo: "baz",
         bing: {
           bong: "buzz",
         },
       };
       const expected2 = [
         {
-          rule:       "rule-one",
-          channel:    "#-baz-",
+          rule: "rule-one",
+          channel: "#-baz-",
           dimensions: ["-baz-"],
         },
         {
-          rule:   "rule-two",
+          rule: "rule-two",
           series: "x",
         },
       ];
@@ -347,137 +366,189 @@ routes:
 describe("router.Rule", () => {
   describe("matches", () => {
     it("works on simple cases", () => {
-      const r = new router.Rule("test-rule", {title: ["hello", "hi"], foo: ["bar"]}, {});
-      assert(r.matches({
-        title: "hello",
-        foo:   "bar",
-      }));
-      assert(r.matches({
-        title: "hi",
-        foo:   "bar",
-      }));
-      assert(!r.matches({
-        title: "hi",
-        foo:   "fighters",
-      }));
-      assert(!r.matches({
-        title: "howdy",
-        foo:   "bar",
-      }));
-      assert(!r.matches({
-        "missing-stuff": "indeed",
-      }));
+      const r = new router.Rule("test-rule", { title: ["hello", "hi"], foo: ["bar"] }, {});
+      assert(
+        r.matches({
+          title: "hello",
+          foo: "bar",
+        }),
+      );
+      assert(
+        r.matches({
+          title: "hi",
+          foo: "bar",
+        }),
+      );
+      assert(
+        !r.matches({
+          title: "hi",
+          foo: "fighters",
+        }),
+      );
+      assert(
+        !r.matches({
+          title: "howdy",
+          foo: "bar",
+        }),
+      );
+      assert(
+        !r.matches({
+          "missing-stuff": "indeed",
+        }),
+      );
     });
 
     it("works on nested messages", () => {
-      const r = new router.Rule("test-rule", {"foo.bar": ["hello", "hi"]}, {});
-      assert(r.matches({
-        title: "greeting",
-        foo: {
-          bar: "hello",
-        },
-      }));
-      assert(r.matches({
-        title: "greeting",
-        foo: {
-          bar: "hi",
-        },
-      }));
-      assert(!r.matches({
-        title: "greeting",
-        foo: {
-          bar: "howdy",
-        },
-      }));
-      assert(!r.matches({
-        title: "greeting",
-        foo: {
-          baz: "howdy",
-        },
-      }));
-      assert(!r.matches({
-        title: "greeting",
-        boo: {
-          bar: "howdy",
-        },
-      }));
-      assert(!r.matches({
-        title: "greeting",
-        foo: "hi",
-      }));
+      const r = new router.Rule("test-rule", { "foo.bar": ["hello", "hi"] }, {});
+      assert(
+        r.matches({
+          title: "greeting",
+          foo: {
+            bar: "hello",
+          },
+        }),
+      );
+      assert(
+        r.matches({
+          title: "greeting",
+          foo: {
+            bar: "hi",
+          },
+        }),
+      );
+      assert(
+        !r.matches({
+          title: "greeting",
+          foo: {
+            bar: "howdy",
+          },
+        }),
+      );
+      assert(
+        !r.matches({
+          title: "greeting",
+          foo: {
+            baz: "howdy",
+          },
+        }),
+      );
+      assert(
+        !r.matches({
+          title: "greeting",
+          boo: {
+            bar: "howdy",
+          },
+        }),
+      );
+      assert(
+        !r.matches({
+          title: "greeting",
+          foo: "hi",
+        }),
+      );
     });
     it("wild card matching", () => {
-      const r = new router.Rule("test-rule", {any: ["*"]}, {});
-      assert(r.matches({
-        any: false,
-      }));
-      assert(r.matches({
-        any: 5,
-      }));
-      assert(r.matches({
-        any: "hello",
-      }));
-      assert(r.matches({
-        any: {
-          bar: "hi",
-        },
-      }));
-      assert(!r.matches({
-        any: "",
-      }));
-      assert(!r.matches({
-        any: null,
-      }));
-      assert(!r.matches({
-        any: undefined,
-      }));
-      assert(!r.matches({
-        title: "greeting",
-        foo: {
-          bar: "howdy",
-        },
-      }));
+      const r = new router.Rule("test-rule", { any: ["*"] }, {});
+      assert(
+        r.matches({
+          any: false,
+        }),
+      );
+      assert(
+        r.matches({
+          any: 5,
+        }),
+      );
+      assert(
+        r.matches({
+          any: "hello",
+        }),
+      );
+      assert(
+        r.matches({
+          any: {
+            bar: "hi",
+          },
+        }),
+      );
+      assert(
+        !r.matches({
+          any: "",
+        }),
+      );
+      assert(
+        !r.matches({
+          any: null,
+        }),
+      );
+      assert(
+        !r.matches({
+          any: undefined,
+        }),
+      );
+      assert(
+        !r.matches({
+          title: "greeting",
+          foo: {
+            bar: "howdy",
+          },
+        }),
+      );
     });
     it("bool matching", () => {
-      const r = new router.Rule("test-rule", {bull: [true]}, {});
-      assert(r.matches({
-        bull: true,
-      }));
-      assert(r.matches({
-        any: false,
-        bull: true,
-      }));
-      assert(!r.matches({
-        bull: false,
-      }));
-      assert(!r.matches({
-        bull: "false",
-      }));
-      assert(!r.matches({
-        title: "greeting",
-        foo: {
-          bar: "howdy",
-        },
-      }));
+      const r = new router.Rule("test-rule", { bull: [true] }, {});
+      assert(
+        r.matches({
+          bull: true,
+        }),
+      );
+      assert(
+        r.matches({
+          any: false,
+          bull: true,
+        }),
+      );
+      assert(
+        !r.matches({
+          bull: false,
+        }),
+      );
+      assert(
+        !r.matches({
+          bull: "false",
+        }),
+      );
+      assert(
+        !r.matches({
+          title: "greeting",
+          foo: {
+            bar: "howdy",
+          },
+        }),
+      );
     });
   });
 
   describe("outputFor", () => {
     it("substitutes kv entries", () => {
-      const r = new router.Rule("myrule", {}, {
-        channel:    "#-%{foo}-",
-        dimensions: ["-%{foo}-", "-%{bar.baz}-"],
-      });
+      const r = new router.Rule(
+        "myrule",
+        {},
+        {
+          channel: "#-%{foo}-",
+          dimensions: ["-%{foo}-", "-%{bar.baz}-"],
+        },
+      );
       const msg = {
         title: "greeting",
-        foo:   "partner",
+        foo: "partner",
         bar: {
           baz: "nest egg",
         },
       };
       const expected = {
-        rule:       "myrule",
-        channel:    "#-partner-",
+        rule: "myrule",
+        channel: "#-partner-",
         dimensions: ["-partner-", "-nest egg-"],
       };
       const actual = r.outputFor(msg);

package/tsconfig.json

@@ -1,7 +1,7 @@
 {
     "compilerOptions": {
         "module": "commonjs",
-        "target": "es5",
+        "target": "ES2019",
         "noImplicitAny": false
     },
     "exclude": [

package/.eslintrc.yml

@@ -1,47 +0,0 @@
-extends: "airbnb"
-env:
-  mocha: true
-parser: "babel-eslint"
-parserOptions:
-  ecmaVersion: 6
-rules:
-  # no hard limit on line length
-  max-len: 0
-
-  # we allow use of console...for now
-  no-console: 0
-
-  # we currently use snake case in most places, however, we'd like to switch to camelCase eventually since it's more common in the JS community
-  camelcase: 0
-
-  # vars are necessary for server-side requires right now
-  no-var: 0
-  vars-on-top: 0
-
-  # multi spaces only allowed for aligning variable/import declarations
-  no-multi-spaces:
-    - 2
-    - exceptions:
-        VariableDeclarator: true
-        ImportDeclaration: true
-
-  # we currently use null in many places, so allow == for null checks
-  eqeqeq:
-    - 2
-    - "smart"
-
-  quotes: [2, "double", "avoid-escape"]
-  object-curly-spacing:
-    - 2
-    - "never"
-  new-cap:
-    - 2
-    - newIsCapExceptions: ["kayvee.logger"]
-  no-param-reassign:
-    - 2
-    - props: false
-  key-spacing:
-    - 2
-    - mode: "minimum"
-
-  guard-for-in: 0

package/tsd.json

@@ -1,15 +0,0 @@
-{
-  "version": "v4",
-  "repo": "borisyankov/DefinitelyTyped",
-  "ref": "master",
-  "path": "typings",
-  "bundle": "typings/tsd.d.ts",
-  "installed": {
-    "node/node.d.ts": {
-      "commit": "641df27e73ca67fa7199a3deedae104198d41a17"
-    },
-    "mocha/mocha.d.ts": {
-      "commit": "641df27e73ca67fa7199a3deedae104198d41a17"
-    }
-  }
-}