Merge remote-tracking branch 'trunk/f-directives' into feature_apollo

Author: joeflack4

README.md

@@ -11,10 +11,21 @@ Mainly useful for applications that need to generate graphql queries dynamically
 npm install json-to-graphql-query
 ```
 
+## Usage
+
+```ts
+const query = jsonToGraphQLQuery(queryObject: object, options?: object);
+```
+
+Supported Options:
+ * `pretty` - boolean - optional - set to `true` to enable pretty-printed output
+ * `ignoreFields` - string[] - optional - you can pass an array of object key names that you want removed from the query
+
 ## Features
 
  * Converts a JavaScript object to a GraphQL Query string
  * Full support for nested query / mutation nodes and arguments
+ * Optionally strip specific object keys using the `ignoreFields` option
  * Support for input arguments via [`__args`](#query-with-arguments)
  * Support for query aliases via [`__alias`](#using-aliases)
  * Support for Enum values via [`EnumType`](#query-with-enum-values)
@@ -24,13 +35,6 @@ npm install json-to-graphql-query
 
 See the [CHANGELOG](CHANGELOG.md)
 
-## Usage
-
-**jsonToGraphQLQuery(** queryObject: object, options?: object **)**
-
-Supported options:
- * **pretty**: boolean - Set to `true` to enable pretty-printed output
-
 ### Simple Query
 
 ```typescript
@@ -60,7 +64,7 @@ query {
 }
 ```
 
-### Query with arguments 
+### Query with arguments
 
 ```typescript
 import { jsonToGraphQLQuery } from 'json-to-graphql-query';
@@ -200,7 +204,7 @@ query {
 }
 ```
 
-### Query with Enum Values 
+### Query with Enum Values
 
 ```typescript
 import { jsonToGraphQLQuery, EnumType } from 'json-to-graphql-query';
@@ -231,7 +235,7 @@ query {
 }
 ```
 
-### Query with variables 
+### Query with variables
 
 ```typescript
 import { jsonToGraphQLQuery, VariableType } from 'json-to-graphql-query';
@@ -266,6 +270,44 @@ query ($variable1: String!, $variableWithDefault: String = "default_value") {
 }
 ```
 
+### Ignoring fields in the query object
+
+We sometimes want to ignore specific fields in the initial object, for instance __typename in Apollo queries.
+You can specify these fields using the `ignoreFields` option:
+
+```typescript
+import { jsonToGraphQLQuery, VariableType } from 'json-to-graphql-query';
+
+const query = {
+    query: {
+        Posts: {
+            shouldBeIgnored: {
+                variable1: 'a value'
+            },
+            id: true,
+            title: true,
+            post_date: true
+        }
+    }
+};
+const graphql_query = jsonToGraphQLQuery(query, {
+    pretty: true,
+    ignoreFields: ['shouldBeIgnored']
+});
+```
+
+Resulting `graphql_query`
+
+```graphql
+query {
+    Posts {
+        id
+        title
+        post_date
+    }
+}
+```
+
 ## TO-DO List
 
  * Support Named Queries / Mutations

src/__tests__/jsonToGraphQLQuery.tests.ts

@@ -1,6 +1,6 @@
 
 import { expect } from 'chai';
-import { jsonToGraphQLQuery, filterNonConfigFields } from '../';
+import { jsonToGraphQLQuery } from '../';
 
 describe('jsonToGraphQL()', () => {
 
@@ -146,79 +146,94 @@ describe('jsonToGraphQL()', () => {
 }`);
     });
 
-    it('Converts a JavaScript object into a valid query, including a single directive w/ no arguments.', () => {
-        interface ILooseObject { [key: string]: any; }
-        let input: ILooseObject = {
-            __typename: 'everyday-health-focuses',
-            diet: {
-                __typename: 'diet',
-                id: 'diet',
-                options: {
-                    __typename: 'diet-options',
-                    calorieCount: {
-                        __typename: 'calorie-count',
-                        category: 'Diet',
-                        icon: 'fa fa-question-circle',
-                        id: 'calorie-count',
-                        selected: false,
-                        text: 'Calorie Count'
+    it('converts a simple query with args and directives with no arguments', () => {
+        const query = {
+            query: {
+                Posts: {
+                    __args: {
+                        where: {
+                            id: 10,
+                        },
+                        orderBy: 'flibble'
+                    },
+                    __directives: {
+                        client: true
                     },
-                    mood: {
-                        __typename: 'mood',
-                        category: 'Diet',
-                        icon: 'fa fa-question-circle',
-                        id: 'mood',
-                        selected: false,
-                        text: 'Mood'
+                    id: true,
+                    title: true,
+                    post_date: true
+                }
+            }
+        } as any;
+        expect(jsonToGraphQLQuery(query, { pretty: true })).to.equal(
+`query {
+    Posts @client (where: {id: 10}, orderBy: 'flibble') {
+        id
+        title
+        post_date
+    }
+}`);
+    });
+
+    it('Converts a complex query with directives with no arguments', () => {
+        const query = {
+            query: {
+                diet: {
+                    __directives: {
+                        client: true
                     },
-                    weight: {
-                        __typename: 'weight',
-                        category: 'Diet',
-                        icon: 'fa fa-question-circle',
-                        id: 'weight',
-                        selected: false,
-                        text: 'Weight'
+                    id: 'diet',
+                    options: {
+                        mood: {
+                            category: 'Diet',
+                            id: 'mood',
+                            selected: true,
+                        },
+                        weight: {
+                            category: 'Diet',
+                            icon: 'fa fa-question-circle',
+                            id: 'weight',
+                            selected: false,
+                            text: 'Weight'
+                        },
                     },
+                    title: 'Diet'
                 },
-                title: 'Diet'
-            },
-            someOtherAbritraryKey: {
-                __typename: 'someArbitraryObjType',
-                arb1: 'arbitrary value',
-                arb2: 'some other arbitrary value'
+                someOtherAbritraryKey: {
+                    __directives: {
+                        client: true
+                    },
+                    arb1: 'arbitrary value',
+                    arb2: 'some other arbitrary value'
+                }
             }
         };
-        Object.keys(input)
-        .filter(filterNonConfigFields)
-        .forEach((key) => {
-            input[key]['__directives'] = { client: true, };
-        });
-        input = {query: input};
-        const expected = 'query { diet @client { id options { calorieCount { category ' +
-        'icon id text } mood { category icon id text } weight { category icon id text } } ' +
+        const expected = 'query { diet @client { id options { ' +
+        'mood { category id selected } weight { category icon id text } } ' +
         'title } someOtherAbritraryKey @client { arb1 arb2 } }';
-        expect(jsonToGraphQLQuery(input)).to.equal(expected);
+        expect(jsonToGraphQLQuery(query)).to.equal(expected);
     });
 
-    it('Converts a JavaScript object into a valid query, including single directives ' +
-    'with args, so long as any variables used are enclosed in a string with "$" included.', () => {
-        interface ILooseObject { [key: string]: any; }
-        let input: ILooseObject = {
-            someOtherAbritraryKey: {
-                __typename: 'someArbitraryObjType',
-                arb1: 'arbitrary value',
-                arb2: 'some other arbitrary value'
-            }
-        };
-        Object.keys(input)
-        .filter(filterNonConfigFields)
-        .forEach((key) => {
-            input[key]['__directives'] = { include: {if: '$isAwesome'}, };
-        });
-        input = {query: input};
-        const expected = 'query { someOtherAbritraryKey @include(if: $isAwesome) { arb1 arb2 } }';
-        expect(jsonToGraphQLQuery(input)).to.equal(expected);
-    });
+    // TODO: Need this test still? How to handle variables unless $ declared explicitly?
+    // it('Converts a JavaScript object into a valid query, including single directives ' +
+    // 'with args, so long as any variables used are enclosed in a string with "$" included.', () => {
+    //     interface ILooseObject { [key: string]: any; }
+    //     let input: ILooseObject = {
+    //         someOtherAbritraryKey: {
+    //             __typename: 'someArbitraryObjType',
+    //             arb1: 'arbitrary value',
+    //             arb2: 'some other arbitrary value'
+    //         }
+    //     };
+    //     Object.keys(input)
+    //     .filter(filterNonConfigFields)
+    //     .forEach((key) => {
+    //         input[key]['__directives'] = { include: {if: '$isAwesome'}, };
+    //     });
+    //     input = {query: input};
+    //     const expected = 'query { someOtherAbritraryKey @include(if: $isAwesome) { arb1 arb2 } }';
+    //     expect(jsonToGraphQLQuery(input)).to.equal(expected);
+    // });
 
     // TODO
     // it('Converts a JavaScript object into a valid query, including *multiple* directives ' +
@@ -365,4 +380,62 @@ describe('jsonToGraphQL()', () => {
         'query { Posts (a: false) { id } Lorem { id } }'
       );
     });
+
+    it('ignores a field that exists in the initial object', () => {
+        const query = {
+            query: {
+                Posts: {
+                    thisShouldBeIgnored: {
+                        test: 'a value'
+                    },
+                    id: true,
+                    title: true,
+                    post_date: true
+                }
+            }
+        };
+        expect(jsonToGraphQLQuery(query, {
+            pretty: true,
+            ignoreFields: ['thisShouldBeIgnored']
+        })).to.equal(
+            `query {
+    Posts {
+        id
+        title
+        post_date
+    }
+}`);
+    });
+
+    it('we can ignore apollo __typename keys', () => {
+        const query = {
+            query: {
+                Posts: {
+                    __typename: 'Posts',
+                    id: true,
+                    title: true,
+                    post_date: true,
+                    subObject: {
+                        __typename: 'subObject',
+                        test: 'a value'
+                    },
+                }
+            }
+        };
+        expect(jsonToGraphQLQuery(query, {
+            pretty: true,
+            ignoreFields: ['__typename']
+        })).to.equal(
+            `query {
+    Posts {
+        id
+        title
+        post_date
+        subObject {
+            test
+        }
+    }
+}`);
+    });
+
 });