chore(Prettier): Add prettier and refactor code style

Author: nodkz

.eslintrc

@@ -1,23 +1,43 @@
 {
-  "extends": "airbnb-base",
-  "parser": "babel-eslint",
-  "plugins": [
-    "flowtype"
+  "extends": [
+    "airbnb-base",
+    "prettier"
   ],
+  "parser": "babel-eslint",
   "rules": {
     "no-underscore-dangle": 0,
-    "no-unused-expressions": 0,
     "arrow-body-style": 0,
-    "no-mixed-operators": 0,
-    "no-restricted-syntax": 0,
+    "arrow-parens": 0,
+    "prefer-template": 0,
+    "no-use-before-define": 0,
+    "no-else-return": 0,
+    "comma-dangle": ["error", {
+      "arrays": "always-multiline",
+      "objects": "always-multiline",
+      "imports": "always-multiline",
+      "exports": "always-multiline",
+      "functions": "ignore",
+    }],
+    "no-plusplus": 0,
+    "import/no-extraneous-dependencies": 0,
     "import/prefer-default-export": 0,
-    "no-lonely-if": 0
+    "prettier/prettier": ["error", {
+      "printWidth": 100,
+      "singleQuote": true,
+      "trailingComma": "es5",
+    }],
+    "no-unused-expressions": 0,
+    "no-restricted-syntax": 0,
   },
   "env": {
     "mocha": true
   },
   "globals": {
     "Class": true,
     "$Shape": true,
-  }
+  },
+  "plugins": [
+    "flowtype",
+    "prettier"
+  ],
 }

package.json

@@ -44,13 +44,16 @@
     "cz-conventional-changelog": "^2.0.0",
     "eslint": "^3.19.0",
     "eslint-config-airbnb-base": "^11.2.0",
+    "eslint-config-prettier": "^2.1.1",
     "eslint-plugin-flowtype": "^2.34.0",
     "eslint-plugin-import": "^2.3.0",
+    "eslint-plugin-prettier": "^2.1.1",
     "flow-bin": "^0.47.0",
     "graphql": "^0.10.1",
     "graphql-compose": "^1.19.0",
     "mocha": "^3.4.2",
     "nyc": "^10.3.2",
+    "prettier": "^1.4.2",
     "rimraf": "^2.6.1",
     "sane": "^1.7.0",
     "semantic-release": "^6.3.2"

src/__mocks__/rootQueryTypeComposer.js

@@ -2,8 +2,7 @@ import { TypeComposer, graphql } from 'graphql-compose';
 
 const RootQuery = new graphql.GraphQLObjectType({
   name: 'RootQuery',
-  fields: {
-  },
+  fields: {},
 });
 
 export const rootQueryTypeComposer = new TypeComposer(RootQuery);

src/__mocks__/userTypeComposer.js

@@ -111,7 +111,7 @@ function prepareFilterFromArgs(resolveParams = {}) {
   const args = resolveParams.args || {};
   const filter = Object.assign({}, args.filter);
   if (resolveParams.rawQuery) {
-    Object.keys(resolveParams.rawQuery).forEach((k) => {
+    Object.keys(resolveParams.rawQuery).forEach(k => {
       filter[k] = resolveParams.rawQuery[k];
     });
   }
@@ -136,9 +136,9 @@ export const findManyResolver = new Resolver({
     limit: GraphQLInt,
     skip: GraphQLInt,
   },
-  resolve: (resolveParams) => {
+  resolve: resolveParams => {
     const args = resolveParams.args || {};
-    const { filter, sort, limit, skip } = args;
+    const { sort, limit, skip } = args;
 
     let list = userList.slice();
     list = sortUserList(list, sort);
@@ -157,49 +157,42 @@ export const findManyResolver = new Resolver({
 });
 userTypeComposer.setResolver('findMany', findManyResolver);
 
-
 export const countResolver = new Resolver({
   name: 'count',
   kind: 'query',
   type: GraphQLInt,
   args: {
     filter: filterArgConfig,
   },
-  resolve: (resolveParams) => {
-    return Promise.resolve(
-      filteredUserList(
-        userList,
-        prepareFilterFromArgs(resolveParams)
-      ).length
-    );
+  resolve: resolveParams => {
+    return Promise.resolve(filteredUserList(userList, prepareFilterFromArgs(resolveParams)).length);
   },
 });
 userTypeComposer.setResolver('count', countResolver);
 
-
 export const sortOptions = {
   ID_ASC: {
     value: { id: 1 },
     cursorFields: ['id'],
-    beforeCursorQuery: (rawQuery, cursorData, resolveParams) => {
+    beforeCursorQuery: (rawQuery, cursorData) => {
       if (!rawQuery.id) rawQuery.id = {};
       rawQuery.id.$lt = cursorData.id;
     },
-    afterCursorQuery: (rawQuery, cursorData, resolveParams) => {
+    afterCursorQuery: (rawQuery, cursorData) => {
       if (!rawQuery.id) rawQuery.id = {};
       rawQuery.id.$gt = cursorData.id;
     },
   },
   AGE_ID_DESC: {
     value: { age: -1, id: -1 },
     cursorFields: ['age', 'id'],
-    beforeCursorQuery: (rawQuery, cursorData, resolveParams) => {
+    beforeCursorQuery: (rawQuery, cursorData) => {
       if (!rawQuery.age) rawQuery.age = {};
       if (!rawQuery.id) rawQuery.id = {};
       rawQuery.age = { $gt: cursorData.age };
       rawQuery.id = { $gt: cursorData.id };
     },
-    afterCursorQuery: (rawQuery, cursorData, resolveParams) => {
+    afterCursorQuery: (rawQuery, cursorData) => {
       if (!rawQuery.age) rawQuery.age = {};
       if (!rawQuery.id) rawQuery.id = {};
       rawQuery.age = { $lt: cursorData.age };

src/__tests__/composeWithConnection-test.js

@@ -26,7 +26,7 @@ describe('composeWithRelay', () => {
 
     it('should throw error if options are empty', () => {
       expect(() => composeWithConnection(userTypeComposer)).to.throw(
-        'should provide non-empty options',
+        'should provide non-empty options'
       );
     });
 
@@ -68,7 +68,7 @@ describe('composeWithRelay', () => {
   it('should apply first sort ID_ASC by default', async () => {
     rootQueryTC.setField(
       'userConnection',
-      userTypeComposer.getResolver('connection').getFieldConfig(),
+      userTypeComposer.getResolver('connection').getFieldConfig()
     );
     const schema = new GraphQLSchema({
       query: rootQueryTC.getType(),
@@ -120,7 +120,7 @@ describe('composeWithRelay', () => {
   it('should able to change `sort` on AGE_ID_DESC', async () => {
     rootQueryTC.setField(
       'userConnection',
-      userTypeComposer.getResolver('connection').getFieldConfig(),
+      userTypeComposer.getResolver('connection').getFieldConfig()
     );
     const schema = new GraphQLSchema({
       query: rootQueryTC.getType(),
@@ -174,7 +174,7 @@ describe('composeWithRelay', () => {
     it('should return object', async () => {
       rootQueryTC.setField(
         'userConnection',
-        userTypeComposer.getResolver('connection').getFieldConfig(),
+        userTypeComposer.getResolver('connection').getFieldConfig()
       );
       const schema = new GraphQLSchema({
         query: rootQueryTC.getType(),
@@ -242,12 +242,12 @@ describe('composeWithRelay', () => {
       'userConnection',
       userTypeComposer
         .getResolver('connection')
-        .wrapResolve(next => (rp) => {
+        .wrapResolve(next => rp => {
           const result = next(rp);
           topResolveParams = rp;
           return result;
         })
-        .getFieldConfig(),
+        .getFieldConfig()
     );
     const schema = new GraphQLSchema({
       query: rootQueryTC.getType(),
@@ -266,7 +266,9 @@ describe('composeWithRelay', () => {
       'info',
       'projection',
     ]);
-    expect(topResolveParams.countResolveParams.args).deep.equal({ filter: { age: 45 } });
+    expect(topResolveParams.countResolveParams.args).deep.equal({
+      filter: { age: 45 },
+    });
   });
 
   it('should pass `findManyResolveParams` to top resolverParams', async () => {
@@ -276,12 +278,12 @@ describe('composeWithRelay', () => {
       'userConnection',
       userTypeComposer
         .getResolver('connection')
-        .wrapResolve(next => (rp) => {
+        .wrapResolve(next => rp => {
           const result = next(rp);
           topResolveParams = rp;
           return result;
         })
-        .getFieldConfig(),
+        .getFieldConfig()
     );
     const schema = new GraphQLSchema({
       query: rootQueryTC.getType(),

src/__tests__/connectionResolver-test.js

@@ -27,7 +27,7 @@ describe('connectionResolver', () => {
 
     it('should throw error if opts.countResolverName are empty', () => {
       expect(() => prepareConnectionResolver(userTypeComposer, {})).to.throw(
-        'should have option `opts.countResolverName`',
+        'should have option `opts.countResolverName`'
       );
     });
 
@@ -37,15 +37,15 @@ describe('connectionResolver', () => {
           countResolverName: 'countDoesNotExists',
           findResolverName: 'findMany',
           sort: sortOptions,
-        }),
+        })
       ).to.throw("should have resolver with name 'countDoesNotExists'");
     });
 
     it('should throw error if opts.findResolverName are empty', () => {
       expect(() =>
         prepareConnectionResolver(userTypeComposer, {
           countResolverName: 'count',
-        }),
+        })
       ).to.throw('should have option `opts.findResolverName`');
     });
 
@@ -55,7 +55,7 @@ describe('connectionResolver', () => {
           countResolverName: 'count',
           findResolverName: 'findManyDoesNotExists',
           sort: sortOptions,
-        }),
+        })
       ).to.throw("should have resolver with name 'findManyDoesNotExists'");
     });
   });
@@ -109,14 +109,14 @@ describe('connectionResolver', () => {
       countResolverCalled = false;
       const mockedFindMany = userTypeComposer
         .getResolver('findMany')
-        .wrapResolve(next => (resolveParams) => {
+        .wrapResolve(next => resolveParams => {
           findManyResolverCalled = true;
           spyResolveParams = resolveParams;
           return next(resolveParams);
         });
       const mockedCount = userTypeComposer
         .getResolver('findMany')
-        .wrapResolve(next => (resolveParams) => {
+        .wrapResolve(next => resolveParams => {
           countResolverCalled = true;
           spyResolveParams = resolveParams;
           return next(resolveParams);

src/__tests__/cursor-test.js

@@ -7,7 +7,10 @@ describe('cursor behavior', () => {
   });
 
   it('should decode object from base64', () => {
-    expect(cursorToData('eyJpZCI6MSwiYWdlIjozMH0=')).to.deep.equal({ id: 1, age: 30 });
+    expect(cursorToData('eyJpZCI6MSwiYWdlIjozMH0=')).to.deep.equal({
+      id: 1,
+      age: 30,
+    });
   });
 
   it('should return null if cursor is invalid', () => {

src/composeWithConnection.js

@@ -1,14 +1,12 @@
 /* @flow */
 
 import { TypeComposer } from 'graphql-compose';
-import type {
-  composeWithConnectionOpts,
-} from './definition';
+import type { composeWithConnectionOpts } from './definition';
 import { prepareConnectionResolver } from './connectionResolver';
 
 export function composeWithConnection(
   typeComposer: TypeComposer,
-  opts: composeWithConnectionOpts,
+  opts: composeWithConnectionOpts
 ): TypeComposer {
   if (!(typeComposer instanceof TypeComposer)) {
     throw new Error('You should provide TypeComposer instance to composeWithRelay method');
@@ -22,10 +20,7 @@ export function composeWithConnection(
     return typeComposer;
   }
 
-  const resolver = prepareConnectionResolver(
-    typeComposer,
-    opts,
-  );
+  const resolver = prepareConnectionResolver(typeComposer, opts);
 
   typeComposer.setResolver('connection', resolver);
   return typeComposer;