feat: support sub-attributes after value paths. (#99)

Allow comparison operations on sub-attributes following value paths.
e.g. `emails[type eq "work"].value eq "[email protected]"`

The tokenizer regex was updated to allow for a trailing dot (.) after a closing square bracket (]) when searching for "Bracket" tokens.
`readValFilter` was then updated to look for any dot after the closing bracket and a following "Word" token. When this happens an implicit `and` op is returned.

One issue with this approach is that any `and` ops before or after this syntax will result in nested `and` ops instead of a single op with more than two filters. Check the last test added to `parse.test.ts` for an example. However, I couldn't figure out a neat way to flattening that use case without a much more disruptive changeset.

fixes: #96

Author: mastermatt

package.json

@@ -15,7 +15,7 @@
     "filter"
   ],
   "scripts": {
-    "watch": "mocha -r ts-node/register  'test/**/*.ts' 'src/**/*.ts' -w --watch-extensions ts",
+    "watch": "mocha -r ts-node/register 'test/**/*.ts' 'src/**/*.ts' -w --watch-extensions ts",
     "build": "tsc",
     "test": "npm run build && mocha 'lib/test/**/*.test.js'"
   },

src/parser.ts

@@ -10,7 +10,7 @@ export type Token = {
 export function tokenizer(f: string): Token[] {
   const ret: Token[] = [];
   let rest = f;
-  const patterns = /^(?:(\s+)|(-?\d+(?:\.\d+)?(?:[eE][-+]?\d+)?)|("(?:[^"]|\\.|\n)*")|([[\]()])|(\w[-\w\._:\/%]*))/;
+  const patterns = /^(?:(\s+)|(-?\d+(?:\.\d+)?(?:[eE][-+]?\d+)?)|("(?:[^"]|\\.|\n)*")|([[()]|]\.?)|(\w[-\w._:\/%]*))/;
   let n;
   while ((n = patterns.exec(rest))) {
     if (n[1] || n[0].length === 0) {
@@ -127,17 +127,26 @@ function readValFilter(left: Token, list: TokenList): Filter {
   const t = list.shift();
   const op = t.literal.toLowerCase();
   if (cops.has(op)) {
-    var compValue = parseCompValue(list);
+    const compValue = parseCompValue(list);
     return { op, attrPath, compValue } as Compare;
   } else if (sops.has(op)) {
     return { op, attrPath } as Suffix;
-  } else if (op == "[") {
+  } else if (op === "[") {
     const valFilter = parseFilter(list);
     const close = list.shift();
-    if (close.literal !== "]") {
+    if (close.literal[0] !== "]") {
       throw new Error(`Unexpected token ${close.literal} expected ']'`);
     }
-    return { op: "[]", attrPath, valFilter } as ValuePath;
+    const valPath: ValuePath = { op: "[]", attrPath, valFilter };
+
+    if (close.literal[1] !== "." || list.peek().type !== "Word") {
+      return valPath
+    }
+
+    // convert a sub-attribute after a value-path to an 'and' op
+    const next = list.shift()
+    next.literal = `${attrPath}.${next.literal}`
+    return { op: 'and', filters: [valPath, readValFilter(next, list)] }
   } else {
     throw new Error(
       `Unexpected token ${attrPath} ${t.literal} as valFilter operator`

test/parse.test.ts

@@ -229,6 +229,30 @@ describe('parse', () => {
       `userType eq "Employee" and emails[type eq "work" and value co "@example.com"]`,
       and(eq("userType", "Employee"), v("emails", and(eq("type", "work"), op("co", "value", "@example.com"))))
     );
+    test(
+        `emails[type eq "work"] and emails.value eq "[email protected]"`,
+      and(
+        v("emails", eq("type", "work")),
+        eq("emails.value", "[email protected]"),
+      )
+    );
+    test(
+      `emails[type eq "work"].value eq "[email protected]"`,
+      and(
+        v("emails", eq("type", "work")),
+        eq("emails.value", "[email protected]"),
+      )
+    );
+    test(
+      `emails[type eq "work"].value eq "[email protected]" and name eq "foo"`,
+      and(
+        and(
+          v("emails", eq("type", "work")),
+          eq("emails.value", "[email protected]"),
+        ),
+        eq("name", "foo"),
+      )
+    );
     test(
       `emails[type eq "work" and value co "@example.com"] or ims[type eq "xmpp" and value co "@foo.com"]`,
       or(

test/tokenizer.test.ts

@@ -6,15 +6,18 @@ const assert = chai.assert;
 
 describe("tokenizer", () => {
   const tok = (literal: string, type: string) => ({ literal, type } as Token);
+
   it("eot", () => {
     assert.deepEqual(tokenizer(""), [EOT]);
   });
+
   it("false", () => {
     assert.deepEqual(tokenizer("false"), [
       { literal: "false", type: "Word" },
       EOT
     ]);
   });
+
   it("userName is AttrPath", () => {
     assert.deepEqual(tokenizer("userName"), [
       { literal: "userName", type: "Word" },
@@ -28,4 +31,22 @@ describe("tokenizer", () => {
       tokenizer("userName eq -12")
     );
   });
+
+  it("sub-attribute after ValPath", () => {
+    assert.deepEqual(
+        tokenizer('emails[type eq "work"].value eq "[email protected]"'),
+        [
+          tok("emails", "Word"),
+          tok("[", "Bracket"),
+          tok("type", "Word"),
+          tok("eq", "Word"),
+          tok("\"work\"", "Quoted"),
+          tok("].", "Bracket"),
+          tok("value", "Word"),
+          tok("eq", "Word"),
+          tok("\"[email protected]\"", "Quoted"),
+          EOT,
+      ]
+    )
+  })
 });