fixed tabbing

Poincare · Poincare · commit 2a5919f28eef · 2018-06-01T00:12:28.000-07:00
diff --git a/docs/source/guides/schema-organization.md b/docs/source/guides/schema-organization.md
@@ -302,7 +302,7 @@ import {
 
 const Query = gql`
   type Query {
-		_empty
+    _empty
   }
 `;
 
@@ -339,12 +339,12 @@ Let's say that we're to implement the resolver for the `authors(id: Int!): Autho
 // inside author.js
 
 const resolvers = {
-	Query: {
-		author: (obj, args, context) => {
-			// something goes on here that we have to fill in
-			return author; 
-		},
-	},
+  Query: {
+    author: (obj, args, context) => {
+      // something goes on here that we have to fill in
+      return author; 
+    },
+  },
 };
 ```
 
@@ -368,8 +368,8 @@ import { schema } from './schema.js';
 const db = getDB();
 
 app.use('/graphql', bodyParser.json(), graphqlExpress({ 
-	schema,
-	context: { db },
+  schema,
+  context: { db },
 }));
 ```
 
@@ -383,20 +383,20 @@ import { schema } from './schema.js';
 const db = getDB();
 
 app.use('/graphql', bodyParser.json(), graphqlExpress({ 
-	schema,
-	context: { db },
+  schema,
+  context: { db },
 }));
 ```
 
 Now, this `db` object will be available to us within the `context` object in the resolver implementation. So, we might write something like this:
 
 ```
 const resolvers = {
-	Query: {
-		author: (obj, args, context) => {
-			return context.db.execute('SELECT * FROM authors WHERE id=?', args.id);
-		},
-	},
+  Query: {
+    author: (obj, args, context) => {
+      return context.db.execute('SELECT * FROM authors WHERE id=?', args.id);
+    },
+  },
 };
 ```
 
@@ -417,39 +417,39 @@ Ideally, our code for the resolver should look something like this:
 import { AuthorModel } from './models/author';
 
 const resolvers = {
-	Query: {
-		author: (obj, args, context) => {
-			return AuthorModel.find(args.id, context);
-		},
-	},
+  Query: {
+    author: (obj, args, context) => {
+      return AuthorModel.find(args.id, context);
+    },
+  },
 };
 ```
 
 Our `AuthorModel` object can be written as:
 
 ```
 export const AuthorModel = {
-	find: (id, context) {
-		const dbResult = context.db.execute('SELECT * FROM authors WHERE id=?', id);	
-		return new Author(dbResult);	
-	}
+  find: (id, context) {
+    const dbResult = context.db.execute('SELECT * FROM authors WHERE id=?', id);  
+    return new Author(dbResult);  
+  }
 };
 ```
 
 where `Author` is a simple data class that contains properties of authors we care about. You might ask: what's the benefit of doing this? Now, we're no longer stuffing our GraphQL resolvers full of logic that's dependent on the database that we're using or the schema within the database. Instead, all the resolvers have to care about is the `Author` object. For example, let's say our `Author` GraphQL type has a `name` type. We may now implement this resolver as:
 
 ```
 const resolvers = {
-	Query: {
-		author: (obj, args, context) => {
-			return AuthorModel.find(args.id, context);
-		},
-	},
-	Author: {
-		name: (obj, args, context) => {
-			return obj.name;
-		},
-	},
+  Query: {
+    author: (obj, args, context) => {
+      return AuthorModel.find(args.id, context);
+    },
+  },
+  Author: {
+    name: (obj, args, context) => {
+      return obj.name;
+    },
+  },
 };
 ```
 
