In this commit: (#9)

- Adding JsonToTypedObjectRewriter class which extends Rewriter class and borrows some logic from ScalarFieldToObjectFieldRewriter
- Adding JsonToTypedObjectRewriter class as an export
- Adding JsonToTypedObjectRewriter tests

The purpose of JsonToTypedObjectRewriter is to deal with a situation in which the initial GraphQL schema used a GraphQLJSON type (graphql-type-json) for a field, but there is subsequent desire to type the GraphQLJSON blob in order to strengthen the contract. The issue is that once the client expects a field to be GraphQLJSON, you can't type it out at the GraphQL layer without breaking said client. JsonToTypedObjectRewriter aims to resolve that issue by rewriting the query for the service but still returning the same response as initially expected by the client.

Author: vgeyvandov

src/rewriters/JsonToTypedObjectRewriter.ts

@@ -0,0 +1,56 @@
+import { ASTNode, FieldNode, SelectionSetNode } from 'graphql';
+import { NodeAndVarDefs } from '../ast';
+import Rewriter, { RewriterOpts } from './Rewriter';
+
+interface ObjectField {
+  name: string;
+  subFields?: ObjectField[];
+}
+
+interface JsonToTypedObjectRewriterOpts extends RewriterOpts {
+  objectFields: ObjectField[];
+}
+
+export default class JsonToTypedObjectRewriter extends Rewriter {
+  protected objectFields: ObjectField[];
+
+  constructor({ fieldName, objectFields }: JsonToTypedObjectRewriterOpts) {
+    super({ fieldName });
+    this.objectFields = objectFields;
+  }
+
+  public matches(nodeAndVars: NodeAndVarDefs, parents: ASTNode[]): boolean {
+    if (!super.matches(nodeAndVars, parents)) return false;
+    const node = nodeAndVars.node as FieldNode;
+    // make sure there's no subselections on this field
+    if (node.selectionSet) return false;
+    return true;
+  }
+
+  public rewriteQuery(nodeAndVarDefs: NodeAndVarDefs): NodeAndVarDefs {
+    const node = nodeAndVarDefs.node as FieldNode;
+    const { variableDefinitions } = nodeAndVarDefs;
+    // if there's a subselection already, just return
+    if (node.selectionSet) return nodeAndVarDefs;
+
+    const selectionSet = this.generateSelectionSet(this.objectFields);
+
+    return {
+      variableDefinitions,
+      node: { ...node, selectionSet }
+    } as NodeAndVarDefs;
+  }
+
+  private generateSelectionSet(fields: ObjectField[]): SelectionSetNode {
+    return {
+      kind: 'SelectionSet',
+      selections: fields.map(({ name, subFields }) => ({
+        kind: 'Field',
+        name: { kind: 'Name', value: name },
+        ...(subFields && {
+          selectionSet: this.generateSelectionSet(subFields)
+        })
+      }))
+    } as SelectionSetNode;
+  }
+}

src/rewriters/index.ts

@@ -4,3 +4,4 @@ export { default as FieldArgsToInputTypeRewriter } from './FieldArgsToInputTypeR
 export { default as FieldArgTypeRewriter } from './FieldArgTypeRewriter';
 export { default as NestFieldOutputsRewriter } from './NestFieldOutputsRewriter';
 export { default as ScalarFieldToObjectFieldRewriter } from './ScalarFieldToObjectFieldRewriter';
+export { default as JsonToTypedObjectRewriter } from './JsonToTypedObjectRewriter';

test/functional/rewriteJsonToTypedObjectRewriter.test.ts

@@ -0,0 +1,223 @@
+import RewriteHandler from '../../src/RewriteHandler';
+import JsonToTypedObjectRewriter from '../../src/rewriters/JsonToTypedObjectRewriter';
+import { gqlFmt } from '../testUtils';
+
+describe('Rewrite query for GraphQLJSON field to be a query for a nested object with multiple scalar and/or object types', () => {
+  it('rewrites a GraphQLJSON field query to be an object field query with multiple scalar subfields', () => {
+    const handler = new RewriteHandler([
+      new JsonToTypedObjectRewriter({
+        fieldName: 'thingJSON',
+        objectFields: [{ name: 'title' }, { name: 'description' }]
+      })
+    ]);
+
+    const query = gqlFmt`
+      query getTheThing {
+        theThing {
+          thingField {
+            id
+            thingJSON
+            color
+          }
+        }
+      }
+    `;
+    const expectedRewrittenQuery = gqlFmt`
+      query getTheThing {
+        theThing {
+          thingField {
+            id
+            thingJSON {
+              title
+              description
+            }
+            color
+          }
+        }
+      }
+    `;
+
+    expect(handler.rewriteRequest(query)).toEqual({
+      query: expectedRewrittenQuery
+    });
+  });
+
+  it('rewrites a GraphQLJSON field query to be an object field query with multiple nested object types and subfields', () => {
+    const handler = new RewriteHandler([
+      new JsonToTypedObjectRewriter({
+        fieldName: 'thingJSON',
+        objectFields: [
+          {
+            name: 'user',
+            subFields: [
+              { name: 'userId' },
+              { name: 'userHandle' },
+              {
+                name: 'item',
+                subFields: [{ name: 'itemMeta' }]
+              }
+            ]
+          }
+        ]
+      })
+    ]);
+
+    const query = gqlFmt`
+      query getTheThing {
+        theThing {
+          thingField {
+            id
+            thingJSON
+            color
+          }
+        }
+      }
+    `;
+    const expectedRewrittenQuery = gqlFmt`
+      query getTheThing {
+        theThing {
+          thingField {
+            id
+            thingJSON {
+              user {
+                userId
+                userHandle
+                item {
+                  itemMeta
+                }
+              }
+            }
+            color
+          }
+        }
+      }
+    `;
+
+    expect(handler.rewriteRequest(query)).toEqual({
+      query: expectedRewrittenQuery
+    });
+  });
+
+  it('works with fragments', () => {
+    const handler = new RewriteHandler([
+      new JsonToTypedObjectRewriter({
+        fieldName: 'thingJSON',
+        objectFields: [{ name: 'title' }, { name: 'description' }]
+      })
+    ]);
+
+    const query = gqlFmt`
+      query getTheThing {
+        theThing {
+          ...thingFragment
+        }
+      }
+
+      fragment thingFragment on Thing {
+        id
+        thingJSON
+      }
+    `;
+    const expectedRewrittenQuery = gqlFmt`
+      query getTheThing {
+        theThing {
+          ...thingFragment
+        }
+      }
+
+      fragment thingFragment on Thing {
+        id
+        thingJSON {
+          title
+          description
+        }
+      }
+    `;
+
+    expect(handler.rewriteRequest(query)).toEqual({
+      query: expectedRewrittenQuery
+    });
+  });
+
+  it('works within repeated and nested fragments', () => {
+    const handler = new RewriteHandler([
+      new JsonToTypedObjectRewriter({
+        fieldName: 'thingJSON',
+        objectFields: [
+          {
+            name: 'user',
+            subFields: [
+              { name: 'userId' },
+              { name: 'userHandle' },
+              {
+                name: 'item',
+                subFields: [{ name: 'itemMeta' }]
+              }
+            ]
+          }
+        ]
+      })
+    ]);
+
+    const query = gqlFmt`
+      query getTheThing {
+        theThing {
+          ...thingFragment
+        }
+        otherThing {
+          ...otherThingFragment
+        }
+      }
+
+      fragment thingFragment on Thing {
+        id
+        thingJSON
+      }
+
+      fragment otherThingFragment on Thing {
+        id
+        edges {
+          node {
+            ...thingFragment
+          }
+        }
+      }
+    `;
+    const expectedRewritenQuery = gqlFmt`
+      query getTheThing {
+        theThing {
+          ...thingFragment
+        }
+        otherThing {
+          ...otherThingFragment
+        }
+      }
+
+      fragment thingFragment on Thing {
+        id
+        thingJSON {
+          user {
+            userId
+            userHandle
+            item {
+              itemMeta
+            }
+          }
+        }
+      }
+
+      fragment otherThingFragment on Thing {
+        id
+        edges {
+          node {
+            ...thingFragment
+          }
+        }
+      }
+    `;
+
+    expect(handler.rewriteRequest(query)).toEqual({
+      query: expectedRewritenQuery
+    });
+  });
+});