New Generic Field Rewriter & Custom Rewriter

src/RewriteHandler.ts

@@ -1,10 +1,18 @@
-import { FragmentDefinitionNode, parse, print } from 'graphql';
+import { ASTNode, FragmentDefinitionNode, parse, print } from 'graphql';
 import { extractPath, FragmentTracer, rewriteDoc, rewriteResultsAtPath } from './ast';
 import Rewriter, { Variables } from './rewriters/Rewriter';
 
 interface RewriterMatch {
   rewriter: Rewriter;
   paths: ReadonlyArray<ReadonlyArray<string>>;
+  // TODO:
+  // - allPaths hasnt been tested for fragments
+  // - Give that allPaths includes non-field paths, there might be paths
+  // that don't match to a key in the results object traversed in
+  // 'rewriteResultsAtPath'. For now the 'includesNonFieldPaths' flag is passed to
+  // this function.
+  allPaths: ReadonlyArray<ReadonlyArray<string>>;
+  nodeMatchAndParents?: ASTNode[];
 }
 
 /**
@@ -40,17 +48,22 @@ export default class RewriteHandler {
         if (isMatch) {
           rewrittenVariables = rewriter.rewriteVariables(rewrittenNodeAndVars, rewrittenVariables);
           rewrittenNodeAndVars = rewriter.rewriteQuery(rewrittenNodeAndVars, rewrittenVariables);
-          const simplePath = extractPath([...parents, rewrittenNodeAndVars.node]);
-          let paths: ReadonlyArray<ReadonlyArray<string>> = [simplePath];
+          const fieldPath = extractPath([...parents, rewrittenNodeAndVars.node]);
+          const anyPath = extractPath([...parents, rewrittenNodeAndVars.node], true);
+          let fieldPaths: ReadonlyArray<ReadonlyArray<string>> = [fieldPath];
+          let allPaths: ReadonlyArray<ReadonlyArray<string>> = [anyPath];
           const fragmentDef = parents.find(({ kind }) => kind === 'FragmentDefinition') as
             | FragmentDefinitionNode
             | undefined;
           if (fragmentDef) {
-            paths = fragmentTracer.prependFragmentPaths(fragmentDef.name.value, simplePath);
+            fieldPaths = fragmentTracer.prependFragmentPaths(fragmentDef.name.value, fieldPath);
+            allPaths = fragmentTracer.prependFragmentPaths(fragmentDef.name.value, anyPath);
           }
           this.matches.push({
             rewriter,
-            paths
+            allPaths,
+            paths: fieldPaths,
+            nodeMatchAndParents: [...parents, rewrittenNodeAndVars.node]
           });
         }
         return isMatch;
@@ -70,15 +83,20 @@ export default class RewriteHandler {
     if (this.hasProcessedResponse) throw new Error('This handler has already returned a response');
     this.hasProcessedResponse = true;
     let rewrittenResponse = response;
-    this.matches.reverse().forEach(({ rewriter, paths }) => {
-      paths.forEach(path => {
-        rewrittenResponse = rewriteResultsAtPath(
-          rewrittenResponse,
-          path,
-          (parentResponse, key, index) => rewriter.rewriteResponse(parentResponse, key, index)
-        );
+    this.matches
+      .reverse()
+      .forEach(({ rewriter, paths: fieldPaths, allPaths, nodeMatchAndParents }) => {
+        const paths = rewriter.includeNonFieldPathsInMatch ? allPaths : fieldPaths;
+        paths.forEach(path => {
+          rewrittenResponse = rewriteResultsAtPath(
+            rewrittenResponse,
+            path,
+            (parentResponse, key, index) =>
+              rewriter.rewriteResponse(parentResponse, key, index, nodeMatchAndParents),
+            rewriter.includeNonFieldPathsInMatch
+          );
+        });
       });
-    });
     return rewrittenResponse;
   }
 }

src/ast.ts

@@ -1,4 +1,11 @@
-import { ASTNode, DocumentNode, FragmentDefinitionNode, VariableDefinitionNode } from 'graphql';
+import {
+  ArgumentNode,
+  ASTNode,
+  DocumentNode,
+  FragmentDefinitionNode,
+  Kind,
+  VariableDefinitionNode
+} from 'graphql';
 import { pushToArrayAtKey } from './utils';
 
 const ignoreKeys = new Set(['loc']);
@@ -239,19 +246,51 @@ export const replaceVariableDefinitions = (
 };
 
 /**
- * return the path that will be returned in the response from from the chain of parents
+ * Return the path that will be returned in the response from the chain of parents.
+ * By default this will only build up paths for field nodes, but the anyKind flag allows
+ * to build paths for any named node.
+ *
+ * It also supports aliases.
  */
 /** @hidden */
-export const extractPath = (parents: ReadonlyArray<ASTNode>): ReadonlyArray<string> => {
+export const extractPath = (
+  parents: ReadonlyArray<ASTNode>,
+  anyKind?: boolean
+): ReadonlyArray<string> => {
   const path: string[] = [];
-  parents.forEach(parent => {
-    if (parent.kind === 'Field') {
-      path.push(parent.name.value);
+  parents.forEach((parent: any) => {
+    if (parent.kind === 'Field' || anyKind) {
+      if (parent.alias) {
+        path.push(parent.alias.value);
+      } else if (parent.name) {
+        path.push(parent.name.value);
+      }
     }
   });
   return path;
 };
 
+/**
+ * return an ArgumentNode with a VariableNode as its value node with matching name.
+ */
+/** @hidden */
+export const astArgVarNode = (argName: string): ArgumentNode => {
+  return {
+    kind: Kind.ARGUMENT,
+    name: {
+      kind: Kind.NAME,
+      value: argName
+    },
+    value: {
+      kind: Kind.VARIABLE,
+      name: {
+        kind: Kind.NAME,
+        value: argName
+      }
+    }
+  };
+};
+
 /** @hidden */
 interface ResultObj {
   [key: string]: any;
@@ -261,14 +300,21 @@ interface ResultObj {
 export const rewriteResultsAtPath = (
   results: ResultObj,
   path: ReadonlyArray<string>,
-  callback: (parentResult: any, key: string, position?: number) => any
+  callback: (parentResult: any, key: string, position?: number) => any,
+  includesNonFieldPaths?: boolean
 ): ResultObj => {
   if (path.length === 0) return results;
 
   const curPathElm = path[0];
   const newResults = { ...results };
   const curResults = results[curPathElm];
 
+  // if results[curPathElm] is an empty array, call the callback response rewriter
+  // because there's nothing left to do.
+  if (Array.isArray(curResults) && curResults.length === 0) {
+    callback(results, curPathElm);
+  }
+
   if (path.length === 1) {
     if (Array.isArray(curResults)) {
       return curResults.reduce(
@@ -281,15 +327,30 @@ export const rewriteResultsAtPath = (
   }
 
   const remainingPath = path.slice(1);
+
+  // If curResults is undefined, and includesNonFieldPaths is true,
+  // then curResults is not a field path, so call the callback to allow rewrites
+  // for non-field paths.
+  if (remainingPath.length && includesNonFieldPaths && curResults === undefined) {
+    callback(results, curPathElm);
+    // Then just continue with the next path
+    return rewriteResultsAtPath(results, remainingPath, callback, includesNonFieldPaths);
+  }
+
   // if the path stops here, just return results without any rewriting
   if (curResults === undefined || curResults === null) return results;
 
   if (Array.isArray(curResults)) {
     newResults[curPathElm] = curResults.map(result =>
-      rewriteResultsAtPath(result, remainingPath, callback)
+      rewriteResultsAtPath(result, remainingPath, callback, includesNonFieldPaths)
     );
   } else {
-    newResults[curPathElm] = rewriteResultsAtPath(curResults, remainingPath, callback);
+    newResults[curPathElm] = rewriteResultsAtPath(
+      curResults,
+      remainingPath,
+      callback,
+      includesNonFieldPaths
+    );
   }
 
   return newResults;

src/rewriters/CustomRewriter.ts

@@ -0,0 +1,73 @@
+import { ASTNode } from 'graphql';
+import { NodeAndVarDefs } from '../ast';
+import Rewriter, { RewriterOpts, Variables } from './Rewriter';
+
+interface CustomRewriterOpts extends RewriterOpts {
+  matchesFn?: (nodeAndVarDefs: NodeAndVarDefs, parents: ReadonlyArray<ASTNode>) => boolean;
+  rewriteQueryFn?: (nodeAndVarDefs: NodeAndVarDefs, variables: Variables) => NodeAndVarDefs;
+  rewriteVariablesFn?: (nodeAndVarDefs: NodeAndVarDefs, variables: Variables) => Variables;
+  rewriteResponseFn?: (
+    response: any,
+    key: string,
+    index?: number,
+    nodeMatchAndParents?: ASTNode[]
+  ) => NodeAndVarDefs;
+}
+
+/**
+ * A Custom rewriter with its Rewriter functions received as arguments.
+ * This Rewriter allows users to write their own rewriter functions.
+ */
+class CustomRewriter extends Rewriter {
+  protected matchesFn: (nodeAndVarDefs: NodeAndVarDefs, parents: ReadonlyArray<ASTNode>) => boolean;
+  protected rewriteQueryFn: (
+    nodeAndVarDefs: NodeAndVarDefs,
+    variables: Variables
+  ) => NodeAndVarDefs;
+  protected rewriteVariablesFn: (nodeAndVarDefs: NodeAndVarDefs, variables: Variables) => Variables;
+  protected rewriteResponseFn: (
+    response: any,
+    key: string,
+    index?: number,
+    nodeMatchAndParents?: ASTNode[]
+  ) => NodeAndVarDefs;
+
+  constructor(options: CustomRewriterOpts) {
+    const {
+      matchesFn,
+      rewriteQueryFn,
+      rewriteVariablesFn,
+      rewriteResponseFn,
+      matchConditions = [() => true],
+      ...rewriterOpts
+    } = options;
+    super({ ...rewriterOpts, matchConditions });
+    this.matchesFn = matchesFn || super.matches;
+    this.rewriteQueryFn = rewriteQueryFn || super.rewriteQuery;
+    this.rewriteVariablesFn = rewriteVariablesFn || super.rewriteVariables;
+    this.rewriteResponseFn = rewriteResponseFn || super.rewriteResponse;
+  }
+
+  public matches(nodeAndVarDefs: NodeAndVarDefs, parents: ReadonlyArray<ASTNode>): boolean {
+    return this.matchesFn(nodeAndVarDefs, parents);
+  }
+
+  public rewriteQuery(nodeAndVarDefs: NodeAndVarDefs, variables: Variables) {
+    return this.rewriteQueryFn(nodeAndVarDefs, variables);
+  }
+
+  public rewriteResponse(
+    response: any,
+    key: string,
+    index?: number,
+    nodeMatchAndParents?: ASTNode[]
+  ) {
+    return this.rewriteResponseFn(response, key, index, nodeMatchAndParents);
+  }
+
+  public rewriteVariables(nodeAndVarDefs: NodeAndVarDefs, variables: Variables): Variables {
+    return this.rewriteVariablesFn(nodeAndVarDefs, variables);
+  }
+}
+
+export default CustomRewriter;