Add SCIM V2 PATCH compilePath support; fix bug in ABNF file.

README.md

@@ -12,7 +12,7 @@ const results = [{ userName: "somebody123" }, { userName: "somebody456" }]
 
 ## Description
 
-This implements a parser and compiler for the [filtering](https://tools.ietf.org/html/rfc7644#section-3.4.2.2) and [sorting](https://tools.ietf.org/html/rfc7644#section-3.4.2.3) features defined in System for Cross-Domain Identity Management (SCIM) Protocol 2.0. It was originally built for use by [AuthX](https://github.com/the-control-group/authx);
+This implements a parser and compiler for the [filtering](https://tools.ietf.org/html/rfc7644#section-3.4.2.2), [sorting](https://tools.ietf.org/html/rfc7644#section-3.4.2.3), and [path](https://tools.ietf.org/html/rfc7644#section-3.5.2) features defined in System for Cross-Domain Identity Management (SCIM) Protocol 2.0. It was originally built for use by [AuthX](https://github.com/the-control-group/authx);
 
 ## Methods & Properties
 
@@ -23,3 +23,7 @@ Compile a SCIM filter expression into a function.
 ### `compileSorter(input: string): (a: any, b: any) => -1 | 0 | 1`
 
 Compile a SCIM sort expression into a function.
+
+### `compilePath(input: string): { path: string, filter?: Expression, subpath?: string }`
+
+Compile a SCIM PATCH path into a path, with an optional subpath and filter expression function. The subpath will only be present if there's a filter separating it from the path. Otherwise, the path includes the subpath. The compiled path may then be used to differentiate paths with or without filters, subpaths, etc.

grammar.abnf

@@ -1,3 +1,5 @@
+patchPath = (attributeGroup *1("." attributePathSegment)) / attributePath
+
 filter = infixLogicalExpression / expression
 
 expression = precedenceGroup / attributeGroup / prefixLogicalExpression / postfixAssertion / infixAssertion
@@ -20,7 +22,7 @@ infixAssertion = attributePath SP infixAssertionOperator SP infixAssertionValue
 infixAssertionOperator = "eq" / "ne" / "co" / "sw" / "ew" / "gt" / "lt" / "ge" / "le"
 infixAssertionValue = null / true / false / number / string
 
-attributePath = [URI ":"] attributePathSegment *("." attributePathSegment)
+attributePath = [URI ":"] attributePathSegment *1("." attributePathSegment)
 attributePathSegment  = ALPHA *("-" / "_" / DIGIT / ALPHA)
 
 ; rfc7159

package.json

@@ -1,7 +1,7 @@
 {
   "name": "scim-query-filter-parser",
   "version": "2.0.4",
-  "description": "Parser for SCIM Filter Query Strings",
+  "description": "Parser for SCIM V2 filters and paths",
   "main": "dist/index.js",
   "scripts": {
     "format": "prettier --list-different --write '**/*.{json,yml,md,ts}'",
@@ -21,7 +21,12 @@
     "scim",
     "scimplecloud",
     "parser",
-    "filter"
+    "filter",
+    "path",
+    "patch",
+    "scimv2",
+    "rfc7644",
+    "rfc7643"
   ],
   "author": "Mike Marcacci <[email protected]>",
   "license": "MIT",

src/Yard.ts

@@ -1,10 +1,23 @@
-type Expression = (data: any) => boolean;
+export type Expression = (data: any) => boolean;
+
+export type SimplePath = {
+  path: string;
+  filter: null;
+  subpath: null;
+};
+
+export type FilterPath = {
+  path: string;
+  filter: Expression;
+  subpath: string | null;
+};
 
 class TrackMap {
   filter = [] as Expression[];
+  patchPath = [] as (SimplePath | FilterPath)[];
   expression = [] as Expression[];
   precedenceGroup = [] as Expression[];
-  attributeGroup = [] as Expression[];
+  attributeGroup = [] as [string[][], Expression][];
   prefixLogicalExpression = [] as Expression[];
   prefixLogicalExpressionOperator = [] as ((
     e: Expression,
@@ -28,6 +41,7 @@ class TrackMap {
 
 class Stat {
   filter = 0 as number;
+  patchPath = 0 as number;
   expression = 0 as number;
   precedenceGroup = 0 as number;
   attributeGroup = 0 as number;
@@ -47,6 +61,7 @@ class Stat {
 
 class StatsMap {
   filter = [] as Stat[];
+  patchPath = [] as Stat[];
   expression = [] as Stat[];
   precedenceGroup = [] as Stat[];
   attributeGroup = [] as Stat[];

src/attributeGroup.ts

@@ -29,9 +29,10 @@ export function attributeGroup(
         );
       }
 
-      yard.tracks.attributeGroup.push((data: any) =>
-        traverse(attributePath[0], data).some(x => filter[0](x))
-      );
+      yard.tracks.attributeGroup.push([
+        attributePath,
+        (data: any) => traverse(attributePath[0], data).some(x => filter[0](x))
+      ]);
 
       break;
   }

src/expression.ts

@@ -24,12 +24,15 @@ export function expression(
 
       const children = [
         ...precedenceGroup,
-        ...attributeGroup,
         ...prefixLogicalExpression,
         ...postfixAssertion,
         ...infixAssertion
       ];
 
+      if (attributeGroup.length) {
+        children.push(attributeGroup[0][1]);
+      }
+
       if (children.length !== 1) {
         throw new Error(
           `INVARIANT: Expected 1 expression, but got ${children.length};`

src/index.test.ts

@@ -1,5 +1,5 @@
 import test from "ava";
-import { compileFilter, compileSorter } from "./index";
+import { compileFilter, compileSorter, compilePath } from "./index";
 
 // Specification and examples are defined here:
 // https://tools.ietf.org/html/rfc7644#section-3.4.2.2
@@ -299,3 +299,38 @@ test("compileSorter() - ", t => {
     [2, 1, 3, 5, 10, 4, 6, 8, 9, 7]
   );
 });
+
+test("compilePath() - extracts path", t => {
+  const pathPath = compilePath(
+    "some.nestedMultiValuedField[type eq 5].subField"
+  );
+  t.is(pathPath.path, "some.nestedMultiValuedField");
+});
+
+test("compilePath() - extracts subpaths", t => {
+  const pathPath = compilePath(
+    "some.nestedMultiValuedField[type eq 5].subField"
+  );
+  t.is(pathPath.subpath, "subField");
+});
+
+test("compilePath() - does not extract non-existent subpaths", t => {
+  const pathPath = compilePath("someTopLevelField");
+  t.is(pathPath.subpath, null);
+});
+test("compilePath() - does not extract non-existent subpaths with filters", t => {
+  const pathPath = compilePath("someTopLevelField.something[type eq 5]");
+  t.is(pathPath.subpath, null);
+});
+
+test("compilePath() - does not extract non-existent filter if there is no filter", t => {
+  const pathPath = compilePath(
+    "some.nestedMultiValuedField[type eq 5].subField"
+  );
+  t.is(typeof pathPath.filter, "function");
+});
+
+test("compilePath() - does not extract non-existent filter", t => {
+  const pathPath = compilePath("some.subField");
+  t.is(pathPath.filter, null);
+});

src/index.ts

@@ -5,6 +5,7 @@ import { Yard } from "./Yard";
 import { extractSortValue } from "./util";
 
 import { filter } from "./filter";
+import { patchPath } from "./patchPath";
 import { expression } from "./expression";
 import { precedenceGroup } from "./precedenceGroup";
 import { attributeGroup } from "./attributeGroup";
@@ -24,8 +25,22 @@ const grammar = new Grammar();
 const parser = new Parser();
 parser.ast = new Ast();
 
+type Expression = (data: any) => boolean;
+type SimplePath = {
+  path: string;
+  filter: null;
+  subpath: null;
+};
+
+type FilterPath = {
+  path: string;
+  filter: Expression;
+  subpath: string | null;
+};
+
 parser.ast.callbacks = {
   filter,
+  patchPath,
   expression,
   precedenceGroup,
   attributeGroup,
@@ -42,6 +57,26 @@ parser.ast.callbacks = {
   attributePathSegment
 };
 
+export function compilePath(input: string): SimplePath | FilterPath {
+  // Parse the patchPath
+  const parseResult = parser.parse(grammar, "patchPath", input);
+  if (!parseResult.success) {
+    throw new Error("Failed to parse!");
+  }
+
+  // Compile the patchPath
+  const yard = new Yard();
+  parser.ast.translate(yard);
+
+  if (yard.tracks.patchPath.length !== 1) {
+    throw new Error(
+      `INVARIANT: Expected 1 patchPath, but got ${yard.tracks.patchPath.length};`
+    );
+  }
+
+  return yard.tracks.patchPath[0];
+}
+
 export function compileFilter(input: string): (data: any) => boolean {
   // Parse the filter
   const parseResult = parser.parse(grammar, "filter", input);

src/patchPath.ts

@@ -0,0 +1,50 @@
+import { ids } from "apg-lib";
+import { Yard } from "./Yard";
+
+export function patchPath(
+  state: typeof ids.SEM_PRE | typeof ids.SEM_POST,
+  chars: number[],
+  phraseIndex: number,
+  phraseLength: number,
+  yard: Yard
+): typeof ids.SEM_OK | typeof ids.SEM_SKIP {
+  switch (state) {
+    case ids.SEM_PRE:
+      yard.pre("patchPath");
+      break;
+
+    case ids.SEM_POST:
+      const { attributePath, attributeGroup, attributePathSegment } = yard.post(
+        "patchPath"
+      );
+
+      const children = [...attributePath, ...attributeGroup];
+
+      if (children.length !== 1) {
+        throw new Error(
+          `INVARIANT: Expected 1 patchPath, but got ${children.length};`
+        );
+      }
+
+      if (attributePath.length) {
+        yard.tracks.patchPath.push({
+          path: attributePath[0].join("."),
+          subpath: null,
+          filter: null
+        });
+      } else {
+        const nestedAttributePath = attributeGroup[0][0];
+        yard.tracks.patchPath.push({
+          path: nestedAttributePath[0].join("."),
+          filter: attributeGroup[0][1],
+          subpath: attributePathSegment.length
+            ? attributePathSegment.reverse().join(".")
+            : null
+        });
+      }
+
+      break;
+  }
+
+  return ids.SEM_OK;
+}